Source Jam - openssh-4.3p2

(compat20 && c->extended_usage == CHAN_EXTENDED_READ && \
        (c->efd != -1 || \
        buffer_len(&c->extended) > 0))

(compat20 && c->extended_usage == CHAN_EXTENDED_WRITE && \
        c->efd != -1 && (!(c->flags & (CHAN_EOF_RCVD|CHAN_CLOSE_RCVD)) || \
        buffer_len(&c->extended) > 0))

00145 {
00146         debug2("channel %d: ibuf empty", c->self);
00147         if (buffer_len(&c->input)) {
00148                 error("channel %d: chan_ibuf_empty for non empty buffer",
00149                     c->self);
00150                 return;
00151         }
00152         switch (c->istate) {
00153         case CHAN_INPUT_WAIT_DRAIN:
00154                 if (compat20) {
00155                         if (!(c->flags & CHAN_CLOSE_SENT))
00156                                 chan_send_eof2(c);
00157                         chan_set_istate(c, CHAN_INPUT_CLOSED);
00158                 } else {
00159                         chan_send_ieof1(c);
00160                         chan_set_istate(c, CHAN_INPUT_WAIT_OCLOSE);
00161                 }
00162                 break;
00163         default:
00164                 error("channel %d: chan_ibuf_empty for istate %d",
00165                     c->self, c->istate);
00166                 break;
00167         }
00168 }

00399 {
00400         if (c->type == SSH_CHANNEL_ZOMBIE) {
00401                 debug2("channel %d: zombie", c->self);
00402                 return 1;
00403         }
00404         if (c->istate != CHAN_INPUT_CLOSED || c->ostate != CHAN_OUTPUT_CLOSED)
00405                 return 0;
00406         if (!compat20) {
00407                 debug2("channel %d: is dead", c->self);
00408                 return 1;
00409         }
00410         if ((datafellows & SSH_BUG_EXTEOF) &&
00411             c->extended_usage == CHAN_EXTENDED_WRITE &&
00412             c->efd != -1 &&
00413             buffer_len(&c->extended) > 0) {
00414                 debug2("channel %d: active efd: %d len %d",
00415                     c->self, c->efd, buffer_len(&c->extended));
00416                 return 0;
00417         }
00418         if (!(c->flags & CHAN_CLOSE_SENT)) {
00419                 if (do_send) {
00420                         chan_send_close2(c);
00421                 } else {
00422                         /* channel would be dead if we sent a close */
00423                         if (c->flags & CHAN_CLOSE_RCVD) {
00424                                 debug2("channel %d: almost dead",
00425                                     c->self);
00426                                 return 1;
00427                         }
00428                 }
00429         }
00430         if ((c->flags & CHAN_CLOSE_SENT) &&
00431             (c->flags & CHAN_CLOSE_RCVD)) {
00432                 debug2("channel %d: is dead", c->self);
00433                 return 1;
00434         }
00435         return 0;
00436 }

00393 {
00394         c->type = SSH_CHANNEL_ZOMBIE;
00395 }

00209 {
00210         debug2("channel %d: obuf empty", c->self);
00211         if (buffer_len(&c->output)) {
00212                 error("channel %d: chan_obuf_empty for non empty buffer",
00213                     c->self);
00214                 return;
00215         }
00216         switch (c->ostate) {
00217         case CHAN_OUTPUT_WAIT_DRAIN:
00218                 chan_shutdown_write(c);
00219                 if (!compat20)
00220                         chan_send_oclose1(c);
00221                 chan_set_ostate(c, CHAN_OUTPUT_CLOSED);
00222                 break;
00223         default:
00224                 error("channel %d: internal error: obuf_empty for ostate %d",
00225                     c->self, c->ostate);
00226                 break;
00227         }
00228 }

00364 {
00365         if (compat20)
00366                 chan_rcvd_eof2(c);
00367         else
00368                 chan_rcvd_ieof1(c);
00369         if (c->ostate == CHAN_OUTPUT_WAIT_DRAIN &&
00370             buffer_len(&c->output) == 0 &&
00371             !CHANNEL_EFD_OUTPUT_ACTIVE(c))
00372                 chan_obuf_empty(c);
00373 }

00376 {
00377         if (compat20)
00378                 chan_rcvd_close2(c);
00379         else
00380                 chan_rcvd_oclose1(c);
00381 }

00130 {
00131         debug2("channel %d: read failed", c->self);
00132         switch (c->istate) {
00133         case CHAN_INPUT_OPEN:
00134                 chan_shutdown_read(c);
00135                 chan_set_istate(c, CHAN_INPUT_WAIT_DRAIN);
00136                 break;
00137         default:
00138                 error("channel %d: chan_read_failed for istate %d",
00139                     c->self, c->istate);
00140                 break;
00141         }
00142 }

00384 {
00385         if (compat20)
00386                 chan_write_failed2(c);
00387         else
00388                 chan_write_failed1(c);
00389 }

02603 {
02604         if (num_permitted_opens >= SSH_MAX_FORWARDS_PER_DIRECTION)
02605                 fatal("channel_request_remote_forwarding: too many forwards");
02606         debug("allow port forwarding to host %s port %d", host, port);
02607 
02608         permitted_opens[num_permitted_opens].host_to_connect = xstrdup(host);
02609         permitted_opens[num_permitted_opens].port_to_connect = port;
02610         num_permitted_opens++;
02611 
02612         all_opens_permitted = 0;
02613 }

01816 {
01817         channel_handler(channel_post, readset, writeset);
01818 }

00144 {
00145         Channel *c;
00146 
00147         if (id < 0 || (u_int)id >= channels_alloc) {
00148                 logit("channel_by_id: %d: bad id", id);
00149                 return NULL;
00150         }
00151         c = channels[id];
00152         if (c == NULL) {
00153                 logit("channel_by_id: %d: bad id: channel free", id);
00154                 return NULL;
00155         }
00156         return c;
00157 }

00672 {
00673         Channel *c = channel_by_id(id);
00674 
00675         if (c == NULL) {
00676                 logit("channel_cancel_cleanup: %d: bad id", id);
00677                 return;
00678         }
00679         c->detach_user = NULL;
00680         c->detach_close = 0;
00681 }

02414 {
02415         u_int i;
02416         int found = 0;
02417 
02418         for (i = 0; i < channels_alloc; i++) {
02419                 Channel *c = channels[i];
02420 
02421                 if (c != NULL && c->type == SSH_CHANNEL_RPORT_LISTENER &&
02422                     strncmp(c->path, host, sizeof(c->path)) == 0 &&
02423                     c->listening_port == port) {
02424                         debug2("%s: close channel %d", __func__, i);
02425                         channel_free(c);
02426                         found = 1;
02427                 }
02428         }
02429 
02430         return (found);
02431 }

02617 {
02618         int i;
02619 
02620         for (i = 0; i < num_permitted_opens; i++)
02621                 if (permitted_opens[i].host_to_connect != NULL)
02622                         xfree(permitted_opens[i].host_to_connect);
02623         num_permitted_opens = 0;
02624 
02625 }

00405 {
00406         u_int i;
00407 
00408         for (i = 0; i < channels_alloc; i++)
00409                 if (channels[i] != NULL)
00410                         channel_close_fds(


Classes
struct	Channel
Defines
#define	SSH_CHANNEL_X11_LISTENER 1
#define	SSH_CHANNEL_PORT_LISTENER 2
#define	SSH_CHANNEL_OPENING 3
#define	SSH_CHANNEL_OPEN 4
#define	SSH_CHANNEL_CLOSED 5
#define	SSH_CHANNEL_AUTH_SOCKET 6
#define	SSH_CHANNEL_X11_OPEN 7
#define	SSH_CHANNEL_INPUT_DRAINING 8
#define	SSH_CHANNEL_OUTPUT_DRAINING 9
#define	SSH_CHANNEL_LARVAL 10
#define	SSH_CHANNEL_RPORT_LISTENER 11
#define	SSH_CHANNEL_CONNECTING 12
#define	SSH_CHANNEL_DYNAMIC 13
#define	SSH_CHANNEL_ZOMBIE 14
#define	SSH_CHANNEL_MAX_TYPE 15
#define	SSH_CHANNEL_PATH_LEN 256
#define	CHAN_EXTENDED_IGNORE 0
#define	CHAN_EXTENDED_READ 1
#define	CHAN_EXTENDED_WRITE 2
#define	CHAN_SES_PACKET_DEFAULT (32*1024)
#define	CHAN_SES_WINDOW_DEFAULT (4*CHAN_SES_PACKET_DEFAULT)
#define	CHAN_TCP_PACKET_DEFAULT (32*1024)
#define	CHAN_TCP_WINDOW_DEFAULT (4*CHAN_TCP_PACKET_DEFAULT)
#define	CHAN_X11_PACKET_DEFAULT (16*1024)
#define	CHAN_X11_WINDOW_DEFAULT (4*CHAN_X11_PACKET_DEFAULT)
#define	CHAN_INPUT_OPEN 0
#define	CHAN_INPUT_WAIT_DRAIN 1
#define	CHAN_INPUT_WAIT_OCLOSE 2
#define	CHAN_INPUT_CLOSED 3
#define	CHAN_OUTPUT_OPEN 0
#define	CHAN_OUTPUT_WAIT_DRAIN 1
#define	CHAN_OUTPUT_WAIT_IEOF 2
#define	CHAN_OUTPUT_CLOSED 3
#define	CHAN_CLOSE_SENT 0x01
#define	CHAN_CLOSE_RCVD 0x02
#define	CHAN_EOF_SENT 0x04
#define	CHAN_EOF_RCVD 0x08
#define	CHAN_RBUF 16*1024
#define	CHANNEL_EFD_INPUT_ACTIVE(c)
#define	CHANNEL_EFD_OUTPUT_ACTIVE(c)
Typedefs
typedef Channel	Channel
typedef void	channel_callback_fn (int, void *)
typedef int	channel_infilter_fn (struct Channel , char , int)
typedef u_char *	channel_outfilter_fn (struct Channel , u_char , u_int )
Functions
Channel *	channel_by_id (int)
Channel *	channel_lookup (int)
Channel *	channel_new (char , int, int, int, int, u_int, u_int, int, char , int)
void	channel_set_fds (int, int, int, int, int, int, u_int)
void	channel_free (Channel *)
void	channel_free_all (void)
void	channel_stop_listening (void)
void	channel_send_open (int)
void	channel_request_start (int, char *, int)
void	channel_register_cleanup (int, channel_callback_fn *, int)
void	channel_register_confirm (int, channel_callback_fn , void )
void	channel_register_filter (int, channel_infilter_fn , channel_outfilter_fn )
void	channel_cancel_cleanup (int)
int	channel_close_fd (int *)
void	channel_send_window_changes (void)
void	channel_input_close (int, u_int32_t, void *)
void	channel_input_close_confirmation (int, u_int32_t, void *)
void	channel_input_data (int, u_int32_t, void *)
void	channel_input_extended_data (int, u_int32_t, void *)
void	channel_input_ieof (int, u_int32_t, void *)
void	channel_input_oclose (int, u_int32_t, void *)
void	channel_input_open_confirmation (int, u_int32_t, void *)
void	channel_input_open_failure (int, u_int32_t, void *)
void	channel_input_port_open (int, u_int32_t, void *)
void	channel_input_window_adjust (int, u_int32_t, void *)
void	channel_prepare_select (fd_set , fd_set , int , u_int , int)
void	channel_after_select (fd_set , fd_set )
void	channel_output_poll (void)
int	channel_not_very_much_buffered_data (void)
void	channel_close_all (void)
int	channel_still_open (void)
char *	channel_open_message (void)
int	channel_find_open (void)
void	channel_set_af (int af)
void	channel_permit_all_opens (void)
void	channel_add_permitted_opens (char *, int)
void	channel_clear_permitted_opens (void)
void	channel_input_port_forward_request (int, int)
int	channel_connect_to (const char *, u_short)
int	channel_connect_by_listen_address (u_short)
void	channel_request_remote_forwarding (const char , u_short, const char , u_short)
int	channel_setup_local_fwd_listener (const char , u_short, const char , u_short, int)
void	channel_request_rforward_cancel (const char *host, u_short port)
int	channel_setup_remote_fwd_listener (const char *, u_short, int)
int	channel_cancel_rport_listener (const char *, u_short)
int	x11_connect_display (void)
int	x11_create_display_inet (int, int, int, u_int , int *)
void	x11_input_open (int, u_int32_t, void *)
void	x11_request_forwarding_with_spoofing (int, const char , const char , const char *)
void	deny_input_open (int, u_int32_t, void *)
void	auth_request_forwarding (void)
int	chan_is_dead (Channel *, int)
void	chan_mark_dead (Channel *)
void	chan_rcvd_oclose (Channel *)
void	chan_read_failed (Channel *)
void	chan_ibuf_empty (Channel *)
void	chan_rcvd_ieof (Channel *)
void	chan_write_failed (Channel *)
void	chan_obuf_empty (Channel *)

channels.h File Reference

Classes

Defines

Typedefs

Functions

Define Documentation

Typedef Documentation

Function Documentation