/*

 * 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>

#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();

    }

    ssh_list_prepend(session->channels, channel);

    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, int window,

    int 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:

  if(channel->state == SSH_CHANNEL_STATE_OPEN)

    err=SSH_OK;

  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, int 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, int len,

    int 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 %d bytes into channel buffer (stderr=%d)", len, is_stderr);

  if (is_stderr == 0) {

    /* 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).