mirror of
https://git.libssh.org/projects/libssh.git
synced 2025-07-22 05:21:51 +03:00
channels: Reformat
Signed-off-by: Jakub Jelen <jjelen@redhat.com> Reviewed-by: Andreas Schneider <asn@cryptomilk.org>
This commit is contained in:
Jakub Jelen
committed by
Andreas Schneider
Andreas Schneider
parent
babd891e82
commit
c799a18d89
269
src/channels.c
269
src/channels.c
@ -166,29 +166,32 @@ uint32_t ssh_channel_new_id(ssh_session session)
|
||||
*
|
||||
* Constructs the channel object.
|
||||
*/
|
||||
SSH_PACKET_CALLBACK(ssh_packet_channel_open_conf){
|
||||
uint32_t channelid=0;
|
||||
SSH_PACKET_CALLBACK(ssh_packet_channel_open_conf)
|
||||
{
|
||||
uint32_t channelid = 0;
|
||||
ssh_channel channel;
|
||||
int rc;
|
||||
(void)type;
|
||||
(void)user;
|
||||
|
||||
SSH_LOG(SSH_LOG_PACKET,"Received SSH2_MSG_CHANNEL_OPEN_CONFIRMATION");
|
||||
SSH_LOG(SSH_LOG_PACKET, "Received SSH2_MSG_CHANNEL_OPEN_CONFIRMATION");
|
||||
|
||||
rc = ssh_buffer_unpack(packet, "d", &channelid);
|
||||
if (rc != SSH_OK)
|
||||
goto error;
|
||||
channel=ssh_channel_from_local(session,channelid);
|
||||
if(channel==NULL){
|
||||
ssh_set_error(session, SSH_FATAL,
|
||||
channel = ssh_channel_from_local(session, channelid);
|
||||
if (channel == NULL) {
|
||||
ssh_set_error(session,
|
||||
SSH_FATAL,
|
||||
"Unknown channel id %" PRIu32,
|
||||
(uint32_t) channelid);
|
||||
(uint32_t)channelid);
|
||||
/* TODO: Set error marking in channel object */
|
||||
|
||||
return SSH_PACKET_USED;
|
||||
}
|
||||
|
||||
rc = ssh_buffer_unpack(packet, "ddd",
|
||||
rc = ssh_buffer_unpack(packet,
|
||||
"ddd",
|
||||
&channel->remote_channel,
|
||||
&channel->remote_window,
|
||||
&channel->remote_maxpacket);
|
||||
@ -196,7 +199,8 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open_conf){
|
||||
goto error;
|
||||
|
||||
SSH_LOG(SSH_LOG_DEBUG,
|
||||
"Received a CHANNEL_OPEN_CONFIRMATION for channel %" PRIu32 ":%" PRIu32,
|
||||
"Received a CHANNEL_OPEN_CONFIRMATION for channel %" PRIu32
|
||||
":%" PRIu32,
|
||||
channel->local_channel,
|
||||
channel->remote_channel);
|
||||
|
||||
@ -235,8 +239,8 @@ error:
|
||||
*
|
||||
* @brief Handle a SSH_CHANNEL_OPEN_FAILURE and set the state of the channel.
|
||||
*/
|
||||
SSH_PACKET_CALLBACK(ssh_packet_channel_open_fail){
|
||||
|
||||
SSH_PACKET_CALLBACK(ssh_packet_channel_open_fail)
|
||||
{
|
||||
ssh_channel channel;
|
||||
char *error = NULL;
|
||||
uint32_t code;
|
||||
@ -244,14 +248,14 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open_fail){
|
||||
(void)user;
|
||||
(void)type;
|
||||
|
||||
channel=channel_from_msg(session,packet);
|
||||
if(channel==NULL){
|
||||
SSH_LOG(SSH_LOG_RARE,"Invalid channel in packet");
|
||||
channel = channel_from_msg(session, packet);
|
||||
if (channel == NULL) {
|
||||
SSH_LOG(SSH_LOG_RARE, "Invalid channel in packet");
|
||||
return SSH_PACKET_USED;
|
||||
}
|
||||
|
||||
rc = ssh_buffer_unpack(packet, "ds", &code, &error);
|
||||
if (rc != SSH_OK){
|
||||
if (rc != SSH_OK) {
|
||||
ssh_set_error(session, SSH_FATAL, "Invalid packet");
|
||||
return SSH_PACKET_USED;
|
||||
}
|
||||
@ -265,13 +269,15 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_open_fail){
|
||||
goto error;
|
||||
}
|
||||
|
||||
ssh_set_error(session, SSH_REQUEST_DENIED,
|
||||
"Channel opening failure: channel %" PRIu32 " error (%" PRIu32 ") %s",
|
||||
ssh_set_error(session,
|
||||
SSH_REQUEST_DENIED,
|
||||
"Channel opening failure: channel %" PRIu32 " error (%" PRIu32
|
||||
") %s",
|
||||
channel->local_channel,
|
||||
code,
|
||||
error);
|
||||
SAFE_FREE(error);
|
||||
channel->state=SSH_CHANNEL_STATE_OPEN_DENIED;
|
||||
channel->state = SSH_CHANNEL_STATE_OPEN_DENIED;
|
||||
|
||||
ssh_callbacks_execute_list(channel->callbacks,
|
||||
ssh_channel_callbacks,
|
||||
@ -403,11 +409,13 @@ end:
|
||||
}
|
||||
|
||||
/* return channel with corresponding local id, or NULL if not found */
|
||||
ssh_channel ssh_channel_from_local(ssh_session session, uint32_t id) {
|
||||
ssh_channel ssh_channel_from_local(ssh_session session, uint32_t id)
|
||||
{
|
||||
struct ssh_iterator *it;
|
||||
ssh_channel channel;
|
||||
|
||||
for (it = ssh_list_get_iterator(session->channels); it != NULL ; it=it->next) {
|
||||
for (it = ssh_list_get_iterator(session->channels); it != NULL;
|
||||
it = it->next) {
|
||||
channel = ssh_iterator_value(ssh_channel, it);
|
||||
if (channel == NULL) {
|
||||
continue;
|
||||
@ -505,24 +513,27 @@ static ssh_channel channel_from_msg(ssh_session session, ssh_buffer packet)
|
||||
uint32_t chan;
|
||||
int rc;
|
||||
|
||||
rc = ssh_buffer_unpack(packet,"d",&chan);
|
||||
rc = ssh_buffer_unpack(packet, "d", &chan);
|
||||
if (rc != SSH_OK) {
|
||||
ssh_set_error(session, SSH_FATAL,
|
||||
ssh_set_error(session,
|
||||
SSH_FATAL,
|
||||
"Getting channel from message: short read");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
channel = ssh_channel_from_local(session, chan);
|
||||
if (channel == NULL) {
|
||||
ssh_set_error(session, SSH_FATAL,
|
||||
ssh_set_error(session,
|
||||
SSH_FATAL,
|
||||
"Server specified invalid channel %" PRIu32,
|
||||
(uint32_t) chan);
|
||||
(uint32_t)chan);
|
||||
}
|
||||
|
||||
return channel;
|
||||
}
|
||||
|
||||
SSH_PACKET_CALLBACK(channel_rcv_change_window) {
|
||||
SSH_PACKET_CALLBACK(channel_rcv_change_window)
|
||||
{
|
||||
ssh_channel channel;
|
||||
uint32_t bytes;
|
||||
int rc;
|
||||
@ -531,7 +542,7 @@ SSH_PACKET_CALLBACK(channel_rcv_change_window) {
|
||||
(void)user;
|
||||
(void)type;
|
||||
|
||||
channel = channel_from_msg(session,packet);
|
||||
channel = channel_from_msg(session, packet);
|
||||
if (channel == NULL) {
|
||||
SSH_LOG(SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session));
|
||||
}
|
||||
@ -545,7 +556,8 @@ SSH_PACKET_CALLBACK(channel_rcv_change_window) {
|
||||
}
|
||||
|
||||
SSH_LOG(SSH_LOG_DEBUG,
|
||||
"Adding %" PRIu32 " bytes to channel (%" PRIu32 ":%" PRIu32 ") (from %" PRIu32 " bytes)",
|
||||
"Adding %" PRIu32 " bytes to channel (%" PRIu32 ":%" PRIu32
|
||||
") (from %" PRIu32 " bytes)",
|
||||
bytes,
|
||||
channel->local_channel,
|
||||
channel->remote_channel,
|
||||
@ -556,7 +568,8 @@ SSH_PACKET_CALLBACK(channel_rcv_change_window) {
|
||||
channel->remote_window += bytes;
|
||||
|
||||
/* Writing to the channel is non-blocking until the receive window is empty.
|
||||
When the receive window becomes non-zero again, call channel_write_wontblock_function. */
|
||||
* When the receive window becomes non-zero again, call
|
||||
* channel_write_wontblock_function. */
|
||||
if (was_empty && bytes > 0) {
|
||||
ssh_callbacks_execute_list(channel->callbacks,
|
||||
ssh_channel_callbacks,
|
||||
@ -694,12 +707,13 @@ SSH_PACKET_CALLBACK(channel_rcv_data)
|
||||
return SSH_PACKET_USED;
|
||||
}
|
||||
|
||||
SSH_PACKET_CALLBACK(channel_rcv_eof) {
|
||||
SSH_PACKET_CALLBACK(channel_rcv_eof)
|
||||
{
|
||||
ssh_channel channel;
|
||||
(void)user;
|
||||
(void)type;
|
||||
|
||||
channel = channel_from_msg(session,packet);
|
||||
channel = channel_from_msg(session, packet);
|
||||
if (channel == NULL) {
|
||||
SSH_LOG(SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session));
|
||||
|
||||
@ -983,13 +997,13 @@ int channel_default_bufferize(ssh_channel channel,
|
||||
{
|
||||
ssh_session session;
|
||||
|
||||
if(channel == NULL) {
|
||||
if (channel == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
session = channel->session;
|
||||
|
||||
if(data == NULL) {
|
||||
if (data == NULL) {
|
||||
ssh_set_error_invalid(session);
|
||||
return -1;
|
||||
}
|
||||
@ -1131,7 +1145,7 @@ int ssh_channel_open_forward(ssh_channel channel, const char *remotehost,
|
||||
|
||||
session = channel->session;
|
||||
|
||||
if(remotehost == NULL || sourcehost == NULL) {
|
||||
if (remotehost == NULL || sourcehost == NULL) {
|
||||
ssh_set_error_invalid(session);
|
||||
return rc;
|
||||
}
|
||||
@ -1527,30 +1541,34 @@ static int channel_write_common(ssh_channel channel,
|
||||
uint32_t effectivelen;
|
||||
int rc;
|
||||
|
||||
if(channel == NULL) {
|
||||
if (channel == NULL) {
|
||||
return -1;
|
||||
}
|
||||
session = channel->session;
|
||||
if(data == NULL) {
|
||||
if (data == NULL) {
|
||||
ssh_set_error_invalid(session);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (len > INT_MAX) {
|
||||
SSH_LOG(SSH_LOG_TRACE,
|
||||
"Length (%" PRIu32 ") is bigger than INT_MAX", len);
|
||||
"Length (%" PRIu32 ") is bigger than INT_MAX",
|
||||
len);
|
||||
return SSH_ERROR;
|
||||
}
|
||||
|
||||
if (channel->local_eof) {
|
||||
ssh_set_error(session, SSH_REQUEST_DENIED,
|
||||
"Can't write to channel %" PRIu32 ":%" PRIu32 " after EOF was sent",
|
||||
ssh_set_error(session,
|
||||
SSH_REQUEST_DENIED,
|
||||
"Can't write to channel %" PRIu32 ":%" PRIu32
|
||||
" after EOF was sent",
|
||||
channel->local_channel,
|
||||
channel->remote_channel);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (channel->state != SSH_CHANNEL_STATE_OPEN || channel->delayed_close != 0) {
|
||||
if (channel->state != SSH_CHANNEL_STATE_OPEN ||
|
||||
channel->delayed_close != 0) {
|
||||
ssh_set_error(session, SSH_REQUEST_DENIED, "Remote channel is closed");
|
||||
|
||||
return -1;
|
||||
@ -1560,25 +1578,30 @@ static int channel_write_common(ssh_channel channel,
|
||||
return SSH_ERROR;
|
||||
}
|
||||
|
||||
if (ssh_waitsession_unblocked(session) == 0){
|
||||
rc = ssh_handle_packets_termination(session, SSH_TIMEOUT_DEFAULT,
|
||||
ssh_waitsession_unblocked, session);
|
||||
if (ssh_waitsession_unblocked(session) == 0) {
|
||||
rc = ssh_handle_packets_termination(session,
|
||||
SSH_TIMEOUT_DEFAULT,
|
||||
ssh_waitsession_unblocked,
|
||||
session);
|
||||
if (rc == SSH_ERROR || !ssh_waitsession_unblocked(session))
|
||||
goto out;
|
||||
}
|
||||
while (len > 0) {
|
||||
if (channel->remote_window < len) {
|
||||
SSH_LOG(SSH_LOG_DEBUG,
|
||||
"Remote window is %" PRIu32 " bytes. going to write %" PRIu32 " bytes",
|
||||
"Remote window is %" PRIu32
|
||||
" bytes. going to write %" PRIu32 " bytes",
|
||||
channel->remote_window,
|
||||
len);
|
||||
/* When the window is zero, wait for it to grow */
|
||||
if(channel->remote_window == 0) {
|
||||
if (channel->remote_window == 0) {
|
||||
/* nothing can be written */
|
||||
SSH_LOG(SSH_LOG_DEBUG,
|
||||
"Wait for a growing window message...");
|
||||
rc = ssh_handle_packets_termination(session, SSH_TIMEOUT_DEFAULT,
|
||||
ssh_channel_waitwindow_termination,channel);
|
||||
SSH_LOG(SSH_LOG_DEBUG, "Wait for a growing window message...");
|
||||
rc = ssh_handle_packets_termination(
|
||||
session,
|
||||
SSH_TIMEOUT_DEFAULT,
|
||||
ssh_channel_waitwindow_termination,
|
||||
channel);
|
||||
if (rc == SSH_ERROR ||
|
||||
!ssh_channel_waitwindow_termination(channel) ||
|
||||
session->session_state == SSH_SESSION_STATE_ERROR ||
|
||||
@ -1600,7 +1623,8 @@ static int channel_write_common(ssh_channel channel,
|
||||
|
||||
rc = ssh_buffer_pack(session->out_buffer,
|
||||
"bd",
|
||||
is_stderr ? SSH2_MSG_CHANNEL_EXTENDED_DATA : SSH2_MSG_CHANNEL_DATA,
|
||||
is_stderr ? SSH2_MSG_CHANNEL_EXTENDED_DATA
|
||||
: SSH2_MSG_CHANNEL_DATA,
|
||||
channel->remote_channel);
|
||||
if (rc != SSH_OK) {
|
||||
ssh_set_error_oom(session);
|
||||
@ -1640,7 +1664,7 @@ static int channel_write_common(ssh_channel channel,
|
||||
|
||||
channel->remote_window -= effectivelen;
|
||||
len -= effectivelen;
|
||||
data = ((uint8_t*)data + effectivelen);
|
||||
data = ((uint8_t *)data + effectivelen);
|
||||
if (channel->counter != NULL) {
|
||||
channel->counter->out_bytes += effectivelen;
|
||||
}
|
||||
@ -1778,12 +1802,13 @@ void ssh_channel_set_blocking(ssh_channel channel, int blocking)
|
||||
*
|
||||
* @brief handle a SSH_CHANNEL_SUCCESS packet and set the channel state.
|
||||
*/
|
||||
SSH_PACKET_CALLBACK(ssh_packet_channel_success){
|
||||
SSH_PACKET_CALLBACK(ssh_packet_channel_success)
|
||||
{
|
||||
ssh_channel channel;
|
||||
(void)type;
|
||||
(void)user;
|
||||
|
||||
channel=channel_from_msg(session,packet);
|
||||
channel = channel_from_msg(session, packet);
|
||||
if (channel == NULL) {
|
||||
SSH_LOG(SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session));
|
||||
return SSH_PACKET_USED;
|
||||
@ -1793,11 +1818,12 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_success){
|
||||
"Received SSH_CHANNEL_SUCCESS on channel (%" PRIu32 ":%" PRIu32 ")",
|
||||
channel->local_channel,
|
||||
channel->remote_channel);
|
||||
if(channel->request_state != SSH_CHANNEL_REQ_STATE_PENDING){
|
||||
SSH_LOG(SSH_LOG_RARE, "SSH_CHANNEL_SUCCESS received in incorrect state %d",
|
||||
if (channel->request_state != SSH_CHANNEL_REQ_STATE_PENDING) {
|
||||
SSH_LOG(SSH_LOG_RARE,
|
||||
"SSH_CHANNEL_SUCCESS received in incorrect state %d",
|
||||
channel->request_state);
|
||||
} else {
|
||||
channel->request_state=SSH_CHANNEL_REQ_STATE_ACCEPTED;
|
||||
channel->request_state = SSH_CHANNEL_REQ_STATE_ACCEPTED;
|
||||
|
||||
ssh_callbacks_execute_list(channel->callbacks,
|
||||
ssh_channel_callbacks,
|
||||
@ -1814,12 +1840,13 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_success){
|
||||
*
|
||||
* @brief Handle a SSH_CHANNEL_FAILURE packet and set the channel state.
|
||||
*/
|
||||
SSH_PACKET_CALLBACK(ssh_packet_channel_failure){
|
||||
SSH_PACKET_CALLBACK(ssh_packet_channel_failure)
|
||||
{
|
||||
ssh_channel channel;
|
||||
(void)type;
|
||||
(void)user;
|
||||
|
||||
channel=channel_from_msg(session,packet);
|
||||
channel = channel_from_msg(session, packet);
|
||||
if (channel == NULL) {
|
||||
SSH_LOG(SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session));
|
||||
|
||||
@ -1830,11 +1857,12 @@ SSH_PACKET_CALLBACK(ssh_packet_channel_failure){
|
||||
"Received SSH_CHANNEL_FAILURE on channel (%" PRIu32 ":%" PRIu32 ")",
|
||||
channel->local_channel,
|
||||
channel->remote_channel);
|
||||
if(channel->request_state != SSH_CHANNEL_REQ_STATE_PENDING){
|
||||
SSH_LOG(SSH_LOG_RARE, "SSH_CHANNEL_FAILURE received in incorrect state %d",
|
||||
if (channel->request_state != SSH_CHANNEL_REQ_STATE_PENDING) {
|
||||
SSH_LOG(SSH_LOG_RARE,
|
||||
"SSH_CHANNEL_FAILURE received in incorrect state %d",
|
||||
channel->request_state);
|
||||
} else {
|
||||
channel->request_state=SSH_CHANNEL_REQ_STATE_DENIED;
|
||||
channel->request_state = SSH_CHANNEL_REQ_STATE_DENIED;
|
||||
|
||||
ssh_callbacks_execute_list(channel->callbacks,
|
||||
ssh_channel_callbacks,
|
||||
@ -1968,17 +1996,17 @@ int ssh_channel_request_pty_size_modes(ssh_channel channel, const char *terminal
|
||||
ssh_buffer buffer = NULL;
|
||||
int rc = SSH_ERROR;
|
||||
|
||||
if(channel == NULL) {
|
||||
if (channel == NULL) {
|
||||
return SSH_ERROR;
|
||||
}
|
||||
session = channel->session;
|
||||
|
||||
if(terminal == NULL) {
|
||||
if (terminal == NULL) {
|
||||
ssh_set_error_invalid(channel->session);
|
||||
return rc;
|
||||
}
|
||||
|
||||
switch(channel->request_state){
|
||||
switch (channel->request_state) {
|
||||
case SSH_CHANNEL_REQ_STATE_NONE:
|
||||
break;
|
||||
default:
|
||||
@ -2965,34 +2993,34 @@ int channel_read_buffer(ssh_channel channel, ssh_buffer buffer, uint32_t count,
|
||||
ssh_session session;
|
||||
char *buffer_tmp = NULL;
|
||||
int r;
|
||||
uint32_t total=0;
|
||||
uint32_t total = 0;
|
||||
|
||||
if(channel == NULL) {
|
||||
if (channel == NULL) {
|
||||
return SSH_ERROR;
|
||||
}
|
||||
session = channel->session;
|
||||
|
||||
if(buffer == NULL) {
|
||||
if (buffer == NULL) {
|
||||
ssh_set_error_invalid(channel->session);
|
||||
return SSH_ERROR;
|
||||
}
|
||||
|
||||
ssh_buffer_reinit(buffer);
|
||||
if(count==0){
|
||||
if (count == 0) {
|
||||
do {
|
||||
r=ssh_channel_poll(channel, is_stderr);
|
||||
if(r < 0){
|
||||
r = ssh_channel_poll(channel, is_stderr);
|
||||
if (r < 0) {
|
||||
return r;
|
||||
}
|
||||
if(r > 0){
|
||||
if (r > 0) {
|
||||
count = r;
|
||||
buffer_tmp = ssh_buffer_allocate(buffer, count);
|
||||
if (buffer_tmp == NULL) {
|
||||
ssh_set_error_oom(session);
|
||||
return SSH_ERROR;
|
||||
}
|
||||
r=ssh_channel_read(channel, buffer_tmp, r, is_stderr);
|
||||
if(r < 0){
|
||||
r = ssh_channel_read(channel, buffer_tmp, r, is_stderr);
|
||||
if (r < 0) {
|
||||
ssh_buffer_pass_bytes_end(buffer, count);
|
||||
return r;
|
||||
}
|
||||
@ -3001,7 +3029,7 @@ int channel_read_buffer(ssh_channel channel, ssh_buffer buffer, uint32_t count,
|
||||
|
||||
return r;
|
||||
}
|
||||
if(ssh_channel_is_eof(channel)){
|
||||
if (ssh_channel_is_eof(channel)) {
|
||||
return 0;
|
||||
}
|
||||
ssh_handle_packets(channel->session, SSH_TIMEOUT_INFINITE);
|
||||
@ -3013,13 +3041,13 @@ int channel_read_buffer(ssh_channel channel, ssh_buffer buffer, uint32_t count,
|
||||
ssh_set_error_oom(session);
|
||||
return SSH_ERROR;
|
||||
}
|
||||
while(total < count){
|
||||
r=ssh_channel_read(channel, buffer_tmp, count - total, is_stderr);
|
||||
if(r<0){
|
||||
while (total < count) {
|
||||
r = ssh_channel_read(channel, buffer_tmp, count - total, is_stderr);
|
||||
if (r < 0) {
|
||||
ssh_buffer_pass_bytes_end(buffer, count);
|
||||
return r;
|
||||
}
|
||||
if(r==0){
|
||||
if (r == 0) {
|
||||
/* Rollback the unused space */
|
||||
ssh_buffer_pass_bytes_end(buffer, count - total);
|
||||
return total;
|
||||
@ -3104,10 +3132,10 @@ int ssh_channel_read_timeout(ssh_channel channel,
|
||||
struct ssh_channel_read_termination_struct ctx;
|
||||
int rc;
|
||||
|
||||
if(channel == NULL) {
|
||||
if (channel == NULL) {
|
||||
return SSH_ERROR;
|
||||
}
|
||||
if(dest == NULL) {
|
||||
if (dest == NULL) {
|
||||
ssh_set_error_invalid(channel->session);
|
||||
return SSH_ERROR;
|
||||
}
|
||||
@ -3120,7 +3148,7 @@ int ssh_channel_read_timeout(ssh_channel channel,
|
||||
}
|
||||
|
||||
if (is_stderr) {
|
||||
stdbuf=channel->stderr_buffer;
|
||||
stdbuf = channel->stderr_buffer;
|
||||
}
|
||||
|
||||
SSH_LOG(SSH_LOG_PACKET,
|
||||
@ -3148,7 +3176,8 @@ int ssh_channel_read_timeout(ssh_channel channel,
|
||||
}
|
||||
|
||||
/*
|
||||
* If the channel is closed or in an error state, reading from it is an error
|
||||
* If the channel is closed or in an error state, reading from it is an
|
||||
* error
|
||||
*/
|
||||
if (session->session_state == SSH_SESSION_STATE_ERROR) {
|
||||
return SSH_ERROR;
|
||||
@ -3158,16 +3187,14 @@ int ssh_channel_read_timeout(ssh_channel channel,
|
||||
return 0;
|
||||
}
|
||||
if (channel->state == SSH_CHANNEL_STATE_CLOSED) {
|
||||
ssh_set_error(session,
|
||||
SSH_FATAL,
|
||||
"Remote channel is closed.");
|
||||
ssh_set_error(session, SSH_FATAL, "Remote channel is closed.");
|
||||
return SSH_ERROR;
|
||||
}
|
||||
len = ssh_buffer_get_len(stdbuf);
|
||||
/* Read count bytes if len is greater, everything otherwise */
|
||||
len = (len > count ? count : len);
|
||||
memcpy(dest, ssh_buffer_get(stdbuf), len);
|
||||
ssh_buffer_pass_bytes(stdbuf,len);
|
||||
ssh_buffer_pass_bytes(stdbuf, len);
|
||||
if (channel->counter != NULL) {
|
||||
channel->counter->in_bytes += len;
|
||||
}
|
||||
@ -3530,12 +3557,15 @@ channel_protocol_select(ssh_channel *rchans, ssh_channel *wchans,
|
||||
for (i = 0; rchans[i] != NULL; i++) {
|
||||
chan = rchans[i];
|
||||
|
||||
while (ssh_channel_is_open(chan) && ssh_socket_data_available(chan->session->socket)) {
|
||||
while (ssh_channel_is_open(chan) &&
|
||||
ssh_socket_data_available(chan->session->socket)) {
|
||||
ssh_handle_packets(chan->session, SSH_TIMEOUT_NONBLOCKING);
|
||||
}
|
||||
|
||||
if ((chan->stdout_buffer && ssh_buffer_get_len(chan->stdout_buffer) > 0) ||
|
||||
(chan->stderr_buffer && ssh_buffer_get_len(chan->stderr_buffer) > 0) ||
|
||||
if ((chan->stdout_buffer &&
|
||||
ssh_buffer_get_len(chan->stdout_buffer) > 0) ||
|
||||
(chan->stderr_buffer &&
|
||||
ssh_buffer_get_len(chan->stderr_buffer) > 0) ||
|
||||
chan->remote_eof) {
|
||||
rout[j] = chan;
|
||||
j++;
|
||||
@ -3544,7 +3574,7 @@ channel_protocol_select(ssh_channel *rchans, ssh_channel *wchans,
|
||||
rout[j] = NULL;
|
||||
|
||||
j = 0;
|
||||
for(i = 0; wchans[i] != NULL; i++) {
|
||||
for (i = 0; wchans[i] != NULL; i++) {
|
||||
chan = wchans[i];
|
||||
/* It's not our business to seek if the file descriptor is writable */
|
||||
if (ssh_socket_data_writable(chan->session->socket) &&
|
||||
@ -3559,7 +3589,8 @@ channel_protocol_select(ssh_channel *rchans, ssh_channel *wchans,
|
||||
for (i = 0; echans[i] != NULL; i++) {
|
||||
chan = echans[i];
|
||||
|
||||
if (!ssh_socket_is_open(chan->session->socket) || ssh_channel_is_closed(chan)) {
|
||||
if (!ssh_socket_is_open(chan->session->socket) ||
|
||||
ssh_channel_is_closed(chan)) {
|
||||
eout[j] = chan;
|
||||
j++;
|
||||
}
|
||||
@ -3610,11 +3641,11 @@ int ssh_channel_select(ssh_channel *readchans, ssh_channel *writechans,
|
||||
int rc;
|
||||
int i;
|
||||
int tm, tm_base;
|
||||
int firstround=1;
|
||||
int firstround = 1;
|
||||
struct ssh_timestamp ts;
|
||||
|
||||
if (timeout != NULL)
|
||||
tm_base = timeout->tv_sec * 1000 + timeout->tv_usec/1000;
|
||||
tm_base = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
|
||||
else
|
||||
tm_base = SSH_TIMEOUT_INFINITE;
|
||||
ssh_timestamp_init(&ts);
|
||||
@ -3632,7 +3663,8 @@ int ssh_channel_select(ssh_channel *readchans, ssh_channel *writechans,
|
||||
exceptchans = &dummy;
|
||||
}
|
||||
|
||||
if (readchans[0] == NULL && writechans[0] == NULL && exceptchans[0] == NULL) {
|
||||
if (readchans[0] == NULL && writechans[0] == NULL &&
|
||||
exceptchans[0] == NULL) {
|
||||
/* No channel to poll?? Go away! */
|
||||
return 0;
|
||||
}
|
||||
@ -3661,8 +3693,12 @@ int ssh_channel_select(ssh_channel *readchans, ssh_channel *writechans,
|
||||
* infrastructure to poll on all sessions.
|
||||
*/
|
||||
do {
|
||||
channel_protocol_select(readchans, writechans, exceptchans,
|
||||
rchans, wchans, echans);
|
||||
channel_protocol_select(readchans,
|
||||
writechans,
|
||||
exceptchans,
|
||||
rchans,
|
||||
wchans,
|
||||
echans);
|
||||
if (rchans[0] != NULL || wchans[0] != NULL || echans[0] != NULL) {
|
||||
/* At least one channel has an event */
|
||||
break;
|
||||
@ -3691,12 +3727,12 @@ int ssh_channel_select(ssh_channel *readchans, ssh_channel *writechans,
|
||||
}
|
||||
}
|
||||
/* Get out if the timeout has elapsed */
|
||||
if (!firstround && ssh_timeout_elapsed(&ts, tm_base)){
|
||||
if (!firstround && ssh_timeout_elapsed(&ts, tm_base)) {
|
||||
break;
|
||||
}
|
||||
/* Here we go */
|
||||
rc = ssh_event_dopoll(event,tm);
|
||||
if (rc != SSH_OK){
|
||||
rc = ssh_event_dopoll(event, tm);
|
||||
if (rc != SSH_OK) {
|
||||
SAFE_FREE(rchans);
|
||||
SAFE_FREE(wchans);
|
||||
SAFE_FREE(echans);
|
||||
@ -3704,22 +3740,28 @@ int ssh_channel_select(ssh_channel *readchans, ssh_channel *writechans,
|
||||
return rc;
|
||||
}
|
||||
tm = ssh_timeout_update(&ts, tm_base);
|
||||
firstround=0;
|
||||
} while(1);
|
||||
firstround = 0;
|
||||
} while (1);
|
||||
|
||||
if (readchans != &dummy) {
|
||||
memcpy(readchans, rchans, (count_ptrs(rchans) + 1) * sizeof(ssh_channel));
|
||||
memcpy(readchans,
|
||||
rchans,
|
||||
(count_ptrs(rchans) + 1) * sizeof(ssh_channel));
|
||||
}
|
||||
if (writechans != &dummy) {
|
||||
memcpy(writechans, wchans, (count_ptrs(wchans) + 1) * sizeof(ssh_channel));
|
||||
memcpy(writechans,
|
||||
wchans,
|
||||
(count_ptrs(wchans) + 1) * sizeof(ssh_channel));
|
||||
}
|
||||
if (exceptchans != &dummy) {
|
||||
memcpy(exceptchans, echans, (count_ptrs(echans) + 1) * sizeof(ssh_channel));
|
||||
memcpy(exceptchans,
|
||||
echans,
|
||||
(count_ptrs(echans) + 1) * sizeof(ssh_channel));
|
||||
}
|
||||
SAFE_FREE(rchans);
|
||||
SAFE_FREE(wchans);
|
||||
SAFE_FREE(echans);
|
||||
if(event)
|
||||
if (event)
|
||||
ssh_event_free(event);
|
||||
return 0;
|
||||
}
|
||||
@ -3801,17 +3843,17 @@ int ssh_channel_open_reverse_forward(ssh_channel channel, const char *remotehost
|
||||
ssh_buffer payload = NULL;
|
||||
int rc = SSH_ERROR;
|
||||
|
||||
if(channel == NULL) {
|
||||
if (channel == NULL) {
|
||||
return rc;
|
||||
}
|
||||
if(remotehost == NULL || sourcehost == NULL) {
|
||||
if (remotehost == NULL || sourcehost == NULL) {
|
||||
ssh_set_error_invalid(channel->session);
|
||||
return rc;
|
||||
}
|
||||
|
||||
session = channel->session;
|
||||
|
||||
if(channel->state != SSH_CHANNEL_STATE_NOT_OPEN)
|
||||
if (channel->state != SSH_CHANNEL_STATE_NOT_OPEN)
|
||||
goto pending;
|
||||
payload = ssh_buffer_new();
|
||||
if (payload == NULL) {
|
||||
@ -3824,7 +3866,7 @@ int ssh_channel_open_reverse_forward(ssh_channel channel, const char *remotehost
|
||||
remoteport,
|
||||
sourcehost,
|
||||
localport);
|
||||
if (rc != SSH_OK){
|
||||
if (rc != SSH_OK) {
|
||||
ssh_set_error_oom(session);
|
||||
goto error;
|
||||
}
|
||||
@ -3865,16 +3907,16 @@ int ssh_channel_open_x11(ssh_channel channel,
|
||||
ssh_buffer payload = NULL;
|
||||
int rc = SSH_ERROR;
|
||||
|
||||
if(channel == NULL) {
|
||||
if (channel == NULL) {
|
||||
return rc;
|
||||
}
|
||||
if(orig_addr == NULL) {
|
||||
if (orig_addr == NULL) {
|
||||
ssh_set_error_invalid(channel->session);
|
||||
return rc;
|
||||
}
|
||||
session = channel->session;
|
||||
|
||||
if(channel->state != SSH_CHANNEL_STATE_NOT_OPEN)
|
||||
if (channel->state != SSH_CHANNEL_STATE_NOT_OPEN)
|
||||
goto pending;
|
||||
|
||||
payload = ssh_buffer_new();
|
||||
@ -3883,10 +3925,7 @@ int ssh_channel_open_x11(ssh_channel channel,
|
||||
goto error;
|
||||
}
|
||||
|
||||
rc = ssh_buffer_pack(payload,
|
||||
"sd",
|
||||
orig_addr,
|
||||
orig_port);
|
||||
rc = ssh_buffer_pack(payload, "sd", orig_addr, orig_port);
|
||||
if (rc != SSH_OK) {
|
||||
ssh_set_error_oom(session);
|
||||
goto error;
|
||||
|
||||
Reference in New Issue
Block a user