/*

* channels.c - SSH channel functions

*

* This file is part of the SSH Library

*

* Copyright (c) 2003-2013 by Aris Adamantiadis

* Copyright (c) 2009-2013 by Andreas Schneider <asn@cryptomilk.org>

*

* The SSH Library is free software; you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation; either version 2.1 of the License, or (at your

* option) any later version.

*

* The SSH Library is distributed in the hope that it will be useful, but

* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public

* License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with the SSH Library; see the file COPYING. If not, write to

* the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,

* MA 02111-1307, USA.

*/

#include "config.h"

#include <limits.h>

#include <stdio.h>

#include <errno.h>

#include <time.h>

#include <stdbool.h>

#ifdef HAVE_SYS_TIME_H

#include <sys/time.h>

#endif /* HAVE_SYS_TIME_H */

#ifndef _WIN32

#include <netinet/in.h>

#include <arpa/inet.h>

#endif

#include "libssh/priv.h"

#include "libssh/ssh2.h"

#include "libssh/buffer.h"

#include "libssh/packet.h"

#include "libssh/socket.h"

#include "libssh/channels.h"

#include "libssh/session.h"

#include "libssh/misc.h"

#include "libssh/messages.h"

#if WITH_SERVER

#include "libssh/server.h"

#endif

#define WINDOWBASE 1280000

#define WINDOWLIMIT (WINDOWBASE/2)

/*

* All implementations MUST be able to process packets with an

* uncompressed payload length of 32768 bytes or less and a total packet

* size of 35000 bytes or less.

*/

#define CHANNEL_MAX_PACKET 32768

#define CHANNEL_INITIAL_WINDOW 64000

/**

* @defgroup libssh_channel The SSH channel functions

* @ingroup libssh

*

* Functions that manage a SSH channel.

*

* @{

*/

static ssh_channel channel_from_msg(ssh_session session, ssh_buffer packet);

/**

* @brief Allocate a new channel.

*

* @param[in] session The ssh session to use.

*

* @return A pointer to a newly allocated channel, NULL on error.

*/

ssh_channel ssh_channel_new(ssh_session session)

{

ssh_channel channel = NULL;

if (session == NULL) {

return NULL;

}

/* Check if we have an authenticated session */

if (!(session->flags & SSH_SESSION_FLAG_AUTHENTICATED)) {

return NULL;

}

channel = calloc(1, sizeof(struct ssh_channel_struct));

if (channel == NULL) {

ssh_set_error_oom(session);

return NULL;

}

channel->stdout_buffer = ssh_buffer_new();

if (channel->stdout_buffer == NULL) {

ssh_set_error_oom(session);

SAFE_FREE(channel);

return NULL;

}

channel->stderr_buffer = ssh_buffer_new();

if (channel->stderr_buffer == NULL) {

ssh_set_error_oom(session);

SSH_BUFFER_FREE(channel->stdout_buffer);

SAFE_FREE(channel);

return NULL;

}

channel->session = session;

channel->exit_status = -1;

channel->flags = SSH_CHANNEL_FLAG_NOT_BOUND;

if (session->channels == NULL) {

session->channels = ssh_list_new();

if (session->channels == NULL) {

ssh_set_error_oom(session);

SSH_BUFFER_FREE(channel->stdout_buffer);

SSH_BUFFER_FREE(channel->stderr_buffer);

SAFE_FREE(channel);

return NULL;

}

}

ssh_list_prepend(session->channels, channel);

/* Set states explicitly */

channel->state = SSH_CHANNEL_STATE_NOT_OPEN;

channel->request_state = SSH_CHANNEL_REQ_STATE_NONE;

return channel;

}

/**

* @internal

*

* @brief Create a new channel identifier.

*

* @param[in] session The SSH session to use.

*

* @return The new channel identifier.

*/

uint32_t ssh_channel_new_id(ssh_session session) {

return ++(session->maxchannel);

}

/**

* @internal

*

* @brief Handle a SSH_PACKET_CHANNEL_OPEN_CONFIRMATION packet.

*

* Constructs the channel object.

*/

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");

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,

"Unknown channel id %"PRIu32,

(uint32_t) channelid);

/* TODO: Set error marking in channel object */

return SSH_PACKET_USED;

}

rc = ssh_buffer_unpack(packet, "ddd",

&channel->remote_channel,

&channel->remote_window,

&channel->remote_maxpacket);

if (rc != SSH_OK)

goto error;

SSH_LOG(SSH_LOG_PROTOCOL,

"Received a CHANNEL_OPEN_CONFIRMATION for channel %d:%d",

channel->local_channel,

channel->remote_channel);

if (channel->state != SSH_CHANNEL_STATE_OPENING) {

SSH_LOG(SSH_LOG_RARE,

"SSH2_MSG_CHANNEL_OPEN_CONFIRMATION received in incorrect "

"channel state %d",

channel->state);

goto error;

}

SSH_LOG(SSH_LOG_PROTOCOL,

"Remote window : %"PRIu32", maxpacket : %"PRIu32,

(uint32_t) channel->remote_window,

(uint32_t) channel->remote_maxpacket);

channel->state = SSH_CHANNEL_STATE_OPEN;

channel->flags &= ~SSH_CHANNEL_FLAG_NOT_BOUND;

return SSH_PACKET_USED;

error:

ssh_set_error(session, SSH_FATAL, "Invalid packet");

return SSH_PACKET_USED;

}

/**

* @internal

*

* @brief Handle a SSH_CHANNEL_OPEN_FAILURE and set the state of the channel.

*/

SSH_PACKET_CALLBACK(ssh_packet_channel_open_fail){

ssh_channel channel;

char *error = NULL;

uint32_t code;

int rc;

(void)user;

(void)type;

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){

ssh_set_error(session, SSH_FATAL, "Invalid packet");

return SSH_PACKET_USED;

}

if (channel->state != SSH_CHANNEL_STATE_OPENING) {

SSH_LOG(SSH_LOG_RARE,

"SSH2_MSG_CHANNEL_OPEN_FAILURE received in incorrect channel "

"state %d",

channel->state);

goto error;

}

ssh_set_error(session, SSH_REQUEST_DENIED,

"Channel opening failure: channel %u error (%"PRIu32") %s",

channel->local_channel,

(uint32_t) code,

error);

SAFE_FREE(error);

channel->state=SSH_CHANNEL_STATE_OPEN_DENIED;

return SSH_PACKET_USED;

error:

ssh_set_error(session, SSH_FATAL, "Invalid packet");

return SSH_PACKET_USED;

}

static int ssh_channel_open_termination(void *c){

ssh_channel channel = (ssh_channel) c;

if (channel->state != SSH_CHANNEL_STATE_OPENING ||

channel->session->session_state == SSH_SESSION_STATE_ERROR)

return 1;

else

return 0;

}

/**

* @internal

*

* @brief Open a channel by sending a SSH_OPEN_CHANNEL message and

* wait for the reply.

*

* @param[in] channel The current channel.

*

* @param[in] type A C string describing the kind of channel (e.g. "exec").

*

* @param[in] window The receiving window of the channel. The window is the

* maximum size of data that can stay in buffers and

* network.

*

* @param[in] maxpacket The maximum packet size allowed (like MTU).

*

* @param[in] payload The buffer containing additional payload for the query.

*

* @return SSH_OK if successful; SSH_ERROR otherwise.

*/

static int

channel_open(ssh_channel channel,

const char *type,

uint32_t window,

uint32_t maxpacket,

ssh_buffer payload)

{

ssh_session session = channel->session;

int err = SSH_ERROR;

int rc;

switch (channel->state) {

case SSH_CHANNEL_STATE_NOT_OPEN:

break;

case SSH_CHANNEL_STATE_OPENING:

goto pending;

case SSH_CHANNEL_STATE_OPEN:

case SSH_CHANNEL_STATE_CLOSED:

case SSH_CHANNEL_STATE_OPEN_DENIED:

goto end;

default:

ssh_set_error(session, SSH_FATAL, "Bad state in channel_open: %d",

channel->state);

}

channel->local_channel = ssh_channel_new_id(session);

channel->local_maxpacket = maxpacket;

channel->local_window = window;

SSH_LOG(SSH_LOG_PROTOCOL,

"Creating a channel %d with %d window and %d max packet",

channel->local_channel, window, maxpacket);

rc = ssh_buffer_pack(session->out_buffer,

"bsddd",

SSH2_MSG_CHANNEL_OPEN,

type,

channel->local_channel,

channel->local_window,

channel->local_maxpacket);

if (rc != SSH_OK) {

ssh_set_error_oom(session);

return err;

}

if (payload != NULL) {

if (ssh_buffer_add_buffer(session->out_buffer, payload) < 0) {

ssh_set_error_oom(session);

return err;

}

}

channel->state = SSH_CHANNEL_STATE_OPENING;

if (ssh_packet_send(session) == SSH_ERROR) {

return err;

}

SSH_LOG(SSH_LOG_PACKET,

"Sent a SSH_MSG_CHANNEL_OPEN type %s for channel %d",

type, channel->local_channel);

pending:

/* wait until channel is opened by server */

err = ssh_handle_packets_termination(session,

SSH_TIMEOUT_DEFAULT,

ssh_channel_open_termination,

channel);

if (session->session_state == SSH_SESSION_STATE_ERROR) {

err = SSH_ERROR;

}

end:

/* This needs to pass the SSH_AGAIN from the above,

* but needs to catch failed channel states */

if (channel->state == SSH_CHANNEL_STATE_OPEN) {

err = SSH_OK;

} else if (err != SSH_AGAIN) {

/* Messages were handled correctly, but he channel state is invalid */

err = SSH_ERROR;

}

return err;

}

/* return channel with corresponding local id, or NULL if not found */

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) {

channel = ssh_iterator_value(ssh_channel, it);

if (channel == NULL) {

continue;

}

if (channel->local_channel == id) {

return channel;

}

}

return NULL;

}

/**

* @internal

* @brief grows the local window and send a packet to the other party

* @param session SSH session

* @param channel SSH channel

* @param minimumsize The minimum acceptable size for the new window.

* @return SSH_OK if successful; SSH_ERROR otherwise.

*/

static int grow_window(ssh_session session,

ssh_channel channel,

uint32_t minimumsize)

{

uint32_t new_window = minimumsize > WINDOWBASE ? minimumsize : WINDOWBASE;

int rc;

if(new_window <= channel->local_window){

SSH_LOG(SSH_LOG_PROTOCOL,

"growing window (channel %d:%d) to %d bytes : not needed (%d bytes)",

channel->local_channel, channel->remote_channel, new_window,

channel->local_window);

return SSH_OK;

}

/* WINDOW_ADJUST packet needs a relative increment rather than an absolute

* value, so we give here the missing bytes needed to reach new_window

*/

rc = ssh_buffer_pack(session->out_buffer,

"bdd",

SSH2_MSG_CHANNEL_WINDOW_ADJUST,

channel->remote_channel,

new_window - channel->local_window);

if (rc != SSH_OK) {

ssh_set_error_oom(session);

goto error;

}

if (ssh_packet_send(session) == SSH_ERROR) {

goto error;

}

SSH_LOG(SSH_LOG_PROTOCOL,

"growing window (channel %d:%d) to %d bytes",

channel->local_channel,

channel->remote_channel,

new_window);

channel->local_window = new_window;

return SSH_OK;

error:

ssh_buffer_reinit(session->out_buffer);

return SSH_ERROR;

}

/**

* @internal

*

* @brief Parse a channel-related packet to resolve it to a ssh_channel.

*

* @param[in] session The current SSH session.

*

* @param[in] packet The buffer to parse packet from. The read pointer will

* be moved after the call.

*

* @return The related ssh_channel, or NULL if the channel is

* unknown or the packet is invalid.

*/

static ssh_channel channel_from_msg(ssh_session session, ssh_buffer packet) {

ssh_channel channel;

uint32_t chan;

int rc;

rc = ssh_buffer_unpack(packet,"d",&chan);

if (rc != SSH_OK) {

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,

"Server specified invalid channel %"PRIu32,

(uint32_t) chan);

}

return channel;

}

SSH_PACKET_CALLBACK(channel_rcv_change_window) {

ssh_channel channel;

uint32_t bytes;

int rc;

(void)user;

(void)type;

channel = channel_from_msg(session,packet);

if (channel == NULL) {

SSH_LOG(SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session));

}

rc = ssh_buffer_unpack(packet, "d", &bytes);

if (channel == NULL || rc != SSH_OK) {

SSH_LOG(SSH_LOG_PACKET,

"Error getting a window adjust message: invalid packet");

return SSH_PACKET_USED;

}

SSH_LOG(SSH_LOG_PROTOCOL,

"Adding %d bytes to channel (%d:%d) (from %d bytes)",

bytes,

channel->local_channel,

channel->remote_channel,

channel->remote_window);

channel->remote_window += bytes;

return SSH_PACKET_USED;

}

/* is_stderr is set to 1 if the data are extended, ie stderr */

SSH_PACKET_CALLBACK(channel_rcv_data){

ssh_channel channel;

ssh_string str;

ssh_buffer buf;

size_t len;

int is_stderr;

int rest;

(void)user;

if(type==SSH2_MSG_CHANNEL_DATA)

is_stderr=0;

else

is_stderr=1;

channel = channel_from_msg(session,packet);

if (channel == NULL) {

SSH_LOG(SSH_LOG_FUNCTIONS,

"%s", ssh_get_error(session));

return SSH_PACKET_USED;

}

if (is_stderr) {

uint32_t ignore;

/* uint32 data type code. we can ignore it */

ssh_buffer_get_u32(packet, &ignore);

}

str = ssh_buffer_get_ssh_string(packet);

if (str == NULL) {

SSH_LOG(SSH_LOG_PACKET, "Invalid data packet!");

return SSH_PACKET_USED;

}

len = ssh_string_len(str);

SSH_LOG(SSH_LOG_PACKET,

"Channel receiving %" PRIdS " bytes data in %d (local win=%d remote win=%d)",

len,

is_stderr,

channel->local_window,

channel->remote_window);

/* What shall we do in this case? Let's accept it anyway */

if (len > channel->local_window) {

SSH_LOG(SSH_LOG_RARE,

"Data packet too big for our window(%" PRIdS " vs %d)",

len,

channel->local_window);

}

if (channel_default_bufferize(channel, ssh_string_data(str), len,

is_stderr) < 0) {

SSH_STRING_FREE(str);

return SSH_PACKET_USED;

}

if (len <= channel->local_window) {

channel->local_window -= len;

} else {

channel->local_window = 0; /* buggy remote */

}

SSH_LOG(SSH_LOG_PACKET,

"Channel windows are now (local win=%d remote win=%d)",

channel->local_window,

channel->remote_window);

SSH_STRING_FREE(str);

if (is_stderr) {

buf = channel->stderr_buffer;

} else {

buf = channel->stdout_buffer;

}

ssh_callbacks_iterate(channel->callbacks,

ssh_channel_callbacks,

channel_data_function) {

if (ssh_buffer_get(buf) == NULL) {

break;

}

rest = ssh_callbacks_iterate_exec(channel_data_function,

channel->session,

channel,

ssh_buffer_get(buf),

ssh_buffer_get_len(buf),

is_stderr);

if (rest > 0) {

if (channel->counter != NULL) {

channel->counter->in_bytes += rest;

}

ssh_buffer_pass_bytes(buf, rest);

}

}

ssh_callbacks_iterate_end();

if (channel->local_window + ssh_buffer_get_len(buf) < WINDOWLIMIT) {

if (grow_window(session, channel, 0) < 0) {

return -1;

}

}

return SSH_PACKET_USED;

}

SSH_PACKET_CALLBACK(channel_rcv_eof) {

ssh_channel channel;

(void)user;

(void)type;

channel = channel_from_msg(session,packet);

if (channel == NULL) {

SSH_LOG(SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session));

return SSH_PACKET_USED;

}

SSH_LOG(SSH_LOG_PACKET,

"Received eof on channel (%d:%d)",

channel->local_channel,

channel->remote_channel);

/* channel->remote_window = 0; */

channel->remote_eof = 1;

ssh_callbacks_execute_list(channel->callbacks,

ssh_channel_callbacks,

channel_eof_function,

channel->session,

channel);

return SSH_PACKET_USED;

}

SSH_PACKET_CALLBACK(channel_rcv_close) {

ssh_channel channel;

(void)user;

(void)type;

channel = channel_from_msg(session,packet);

if (channel == NULL) {

SSH_LOG(SSH_LOG_FUNCTIONS, "%s", ssh_get_error(session));

return SSH_PACKET_USED;

}

SSH_LOG(SSH_LOG_PACKET,

"Received close on channel (%d:%d)",

channel->local_channel,

channel->remote_channel);

if ((channel->stdout_buffer &&

ssh_buffer_get_len(channel->stdout_buffer) > 0) ||

(channel->stderr_buffer &&

ssh_buffer_get_len(channel->stderr_buffer) > 0)) {

channel->delayed_close = 1;

} else {

channel->state = SSH_CHANNEL_STATE_CLOSED;

}

if (channel->remote_eof == 0) {

SSH_LOG(SSH_LOG_PACKET,

"Remote host not polite enough to send an eof before close");

}

channel->remote_eof = 1;

/*

* The remote eof doesn't break things if there was still data into read

* buffer because the eof is ignored until the buffer is empty.

*/

ssh_callbacks_execute_list(channel->callbacks,

ssh_channel_callbacks,

channel_close_function,

channel->session,

channel);

channel->flags |= SSH_CHANNEL_FLAG_CLOSED_REMOTE;

if(channel->flags & SSH_CHANNEL_FLAG_FREED_LOCAL)

ssh_channel_do_free(channel);

return SSH_PACKET_USED;

}

SSH_PACKET_CALLBACK(channel_rcv_request) {

ssh_channel channel;

char *request=NULL;

uint8_t status;

int rc;

(void)user;

(void)type;

channel = channel_from_msg(session,packet);

if (channel == NULL) {

SSH_LOG(SSH_LOG_FUNCTIONS,"%s", ssh_get_error(session));

return SSH_PACKET_USED;

}

rc = ssh_buffer_unpack(packet, "sb",

&request,

&status);

if (rc != SSH_OK) {

SSH_LOG(SSH_LOG_PACKET, "Invalid MSG_CHANNEL_REQUEST");

return SSH_PACKET_USED;

}

if (strcmp(request,"exit-status") == 0) {

SAFE_FREE(request);

rc = ssh_buffer_unpack(packet, "d", &channel->exit_status);

if (rc != SSH_OK) {

SSH_LOG(SSH_LOG_PACKET, "Invalid exit-status packet");

return SSH_PACKET_USED;

}

SSH_LOG(SSH_LOG_PACKET, "received exit-status %d", channel->exit_status);

ssh_callbacks_execute_list(channel->callbacks,

ssh_channel_callbacks,

channel_exit_status_function,

channel->session,

channel,

channel->exit_status);

return SSH_PACKET_USED;

}

if (strcmp(request,"signal") == 0) {

char *sig = NULL;

SAFE_FREE(request);

SSH_LOG(SSH_LOG_PACKET, "received signal");

rc = ssh_buffer_unpack(packet, "s", &sig);

if (rc != SSH_OK) {

SSH_LOG(SSH_LOG_PACKET, "Invalid MSG_CHANNEL_REQUEST");

return SSH_PACKET_USED;

}

SSH_LOG(SSH_LOG_PACKET,

"Remote connection sent a signal SIG %s", sig);

ssh_callbacks_execute_list(channel->callbacks,

ssh_channel_callbacks,

channel_signal_function,

channel->session,

channel,

sig);

SAFE_FREE(sig);

return SSH_PACKET_USED;

}

if (strcmp(request, "exit-signal") == 0) {

const char *core = "(core dumped)";

char *sig = NULL;

char *errmsg = NULL;

char *lang = NULL;

uint8_t core_dumped;

SAFE_FREE(request);

rc = ssh_buffer_unpack(packet, "sbss",

&sig, /* signal name */

&core_dumped, /* core dumped */

&errmsg, /* error message */

&lang);

if (rc != SSH_OK) {

SSH_LOG(SSH_LOG_PACKET, "Invalid MSG_CHANNEL_REQUEST");

return SSH_PACKET_USED;

}

if (core_dumped == 0) {

core = "";

}

SSH_LOG(SSH_LOG_PACKET,

"Remote connection closed by signal SIG %s %s", sig, core);

ssh_callbacks_execute_list(channel->callbacks,

ssh_channel_callbacks,

channel_exit_signal_function,

channel->session,

channel,

sig,

core_dumped,

errmsg,

lang);

SAFE_FREE(lang);

SAFE_FREE(errmsg);

SAFE_FREE(sig);

return SSH_PACKET_USED;

}

if(strcmp(request,"keepalive@openssh.com")==0){

SAFE_FREE(request);

SSH_LOG(SSH_LOG_PROTOCOL,"Responding to Openssh's keepalive");

rc = ssh_buffer_pack(session->out_buffer,

"bd",

SSH2_MSG_CHANNEL_FAILURE,

channel->remote_channel);

if (rc != SSH_OK) {

return SSH_PACKET_USED;

}

ssh_packet_send(session);

return SSH_PACKET_USED;

}

if (strcmp(request, "auth-agent-req@openssh.com") == 0) {

SAFE_FREE(request);

SSH_LOG(SSH_LOG_PROTOCOL, "Received an auth-agent-req request");

ssh_callbacks_execute_list(channel->callbacks,

ssh_channel_callbacks,

channel_auth_agent_req_function,

channel->session,

channel);

return SSH_PACKET_USED;

}

#ifdef WITH_SERVER

/* If we are here, that means we have a request that is not in the understood

* client requests. That means we need to create a ssh message to be passed

* to the user code handling ssh messages

*/

ssh_message_handle_channel_request(session,channel,packet,request,status);

#else

SSH_LOG(SSH_LOG_WARNING, "Unhandled channel request %s", request);

#endif

SAFE_FREE(request);

return SSH_PACKET_USED;

}

/*

* When data has been received from the ssh server, it can be applied to the

* known user function, with help of the callback, or inserted here

*

* FIXME is the window changed?

*/

int channel_default_bufferize(ssh_channel channel,

void *data, size_t len,

bool is_stderr)

{

ssh_session session;

if(channel == NULL) {

return -1;

}

session = channel->session;

if(data == NULL) {

ssh_set_error_invalid(session);

return -1;

}

SSH_LOG(SSH_LOG_PACKET,

"placing %zu bytes into channel buffer (%s)",

len,

is_stderr ? "stderr" : "stdout");

if (!is_stderr) {

/* stdout */

if (channel->stdout_buffer == NULL) {

channel->stdout_buffer = ssh_buffer_new();

if (channel->stdout_buffer == NULL) {

ssh_set_error_oom(session);

return -1;

}

}

if (ssh_buffer_add_data(channel->stdout_buffer, data, len) < 0) {

ssh_set_error_oom(session);

SSH_BUFFER_FREE(channel->stdout_buffer);

channel->stdout_buffer = NULL;

return -1;

}

} else {

/* stderr */

if (channel->stderr_buffer == NULL) {

channel->stderr_buffer = ssh_buffer_new();

if (channel->stderr_buffer == NULL) {

ssh_set_error_oom(session);

return -1;

}

}

if (ssh_buffer_add_data(channel->stderr_buffer, data, len) < 0) {

ssh_set_error_oom(session);

SSH_BUFFER_FREE(channel->stderr_buffer);

channel->stderr_buffer = NULL;

return -1;

}

}

return 0;

}

/**

* @brief Open a session channel (suited for a shell, not TCP forwarding).

*

* @param[in] channel An allocated channel.

*

* @return SSH_OK on success,

* SSH_ERROR if an error occurred,

* SSH_AGAIN if in nonblocking mode and call has

* to be done again.

*

* @see ssh_channel_open_forward()

* @see ssh_channel_request_env()

* @see ssh_channel_request_shell()

* @see ssh_channel_request_exec()

*/

int ssh_channel_open_session(ssh_channel channel) {

if(channel == NULL) {

return SSH_ERROR;

}

return channel_open(channel,

"session",

CHANNEL_INITIAL_WINDOW,

CHANNEL_MAX_PACKET,

NULL);

}

/**

* @brief Open an agent authentication forwarding channel. This type of channel

* can be opened by a server towards a client in order to provide SSH-Agent services

* to the server-side process. This channel can only be opened if the client

* claimed support by sending a channel request beforehand.

*

* @param[in] channel An allocated channel.

*

* @return SSH_OK on success,

* SSH_ERROR if an error occurred,

* SSH_AGAIN if in nonblocking mode and call has

* to be done again.

*

* @see ssh_channel_open_forward()

*/

int ssh_channel_open_auth_agent(ssh_channel channel){

if(channel == NULL) {

return SSH_ERROR;

}

return channel_open(channel,

"auth-agent@openssh.com",

CHANNEL_INITIAL_WINDOW,

CHANNEL_MAX_PACKET,

NULL);

}

/**

* @brief Open a TCP/IP forwarding channel.

*

* @param[in] channel An allocated channel.

*

* @param[in] remotehost The remote host to connected (host name or IP).

*

* @param[in] remoteport The remote port.

*

* @param[in] sourcehost The numeric IP address of the machine from where the

* connection request originates. This is mostly for

* logging purposes.

*

* @param[in] localport The port on the host from where the connection

* originated. This is mostly for logging purposes.

*

* @return SSH_OK on success,

* SSH_ERROR if an error occurred,

* SSH_AGAIN if in nonblocking mode and call has

* to be done again.

*

* @warning This function does not bind the local port and does not automatically

* forward the content of a socket to the channel. You still have to

* use channel_read and channel_write for this.

*/

int ssh_channel_open_forward(ssh_channel channel, const char *remotehost,

int remoteport, const char *sourcehost, int localport) {

ssh_session session;

ssh_buffer payload = NULL;

ssh_string str = NULL;

int rc = SSH_ERROR;