int SSH::runCommand(const std::string& cmd, std::string* output) {
int rc;
ssh_channel channel;
channel = ssh_channel_new(session_);
if (channel == NULL) {
rc = SSH_ERROR;
} else {
rc = ssh_channel_open_session(channel);
if (rc != SSH_OK) {
ssh_channel_free(channel);
} else {
char buffer[256];
rc = ssh_channel_request_exec(channel, cmd.c_str());
if (rc == SSH_OK) {
while ((rc = ssh_channel_read(channel, buffer, sizeof(buffer), 0)) > 0) {
output->append(buffer, rc);
}
}
ssh_channel_send_eof(channel);
ssh_channel_close(channel);
ssh_channel_free(channel);
}
}
return rc;
}
/** @internal
* @brief Calculates the RTT of the host with SSH channel operations, and
* returns the average of the calculated RTT.
* @param[in] session active SSH session to test.
* @param[out] average average RTT in milliseconds.
* @returns 0 on success, -1 if there is an error.
*/
int benchmarks_ssh_latency(ssh_session session, float *average){
float times[3];
struct timestamp_struct ts;
int i;
ssh_channel channel;
channel=ssh_channel_new(session);
if(channel==NULL)
goto error;
if(ssh_channel_open_session(channel)==SSH_ERROR)
goto error;
for(i=0;i<3;++i){
timestamp_init(&ts);
if(ssh_channel_request_env(channel,"TEST","test")==SSH_ERROR &&
ssh_get_error_code(session)==SSH_FATAL)
goto error;
times[i]=elapsed_time(&ts);
}
ssh_channel_close(channel);
ssh_channel_free(channel);
channel=NULL;
printf("Times : %f ms ; %f ms ; %f ms\n", times[0], times[1], times[2]);
*average=(times[0]+times[1]+times[2])/3;
return 0;
error:
fprintf(stderr,"Error calculating SSH latency : %s\n",ssh_get_error(session));
if(channel)
ssh_channel_free(channel);
return -1;
}
static ssh_channel run_ssh_command(ssh_session sshs, const char* capture_bin, const char* iface, const char* cfilter,
unsigned long int count)
{
gchar* cmdline;
ssh_channel channel;
char* quoted_bin;
char* quoted_iface;
char* default_filter;
char* quoted_filter;
char* count_str = NULL;
unsigned int remote_port = 22;
if (!capture_bin)
capture_bin = DEFAULT_CAPTURE_BIN;
if (!iface)
iface = "eth0";
channel = ssh_channel_new(sshs);
if (!channel)
return NULL;
if (ssh_channel_open_session(channel) != SSH_OK) {
ssh_channel_free(channel);
return NULL;
}
ssh_options_get_port(sshs, &remote_port);
/* escape parameters to go save with the shell */
quoted_bin = g_shell_quote(capture_bin);
quoted_iface = g_shell_quote(iface);
default_filter = local_interfaces_to_filter(remote_port);
if (!cfilter)
cfilter = default_filter;
quoted_filter = g_shell_quote(cfilter);
if (count > 0)
count_str = g_strdup_printf("-c %lu", count);
cmdline = g_strdup_printf("%s -i %s -P -w - -f %s %s", quoted_bin, quoted_iface, quoted_filter,
count_str ? count_str : "");
verbose_print("Running: %s\n", cmdline);
if (ssh_channel_request_exec(channel, cmdline) != SSH_OK) {
ssh_channel_close(channel);
ssh_channel_free(channel);
channel = NULL;
}
g_free(quoted_bin);
g_free(quoted_iface);
g_free(default_filter);
g_free(quoted_filter);
g_free(cmdline);
if (count_str)
g_free(count_str);
return channel;
}
int show_remote_processes(ssh_session session) {
ssh_channel channel;
int rc;
char buffer[256];
int nbytes;
channel = ssh_channel_new(session);
if (channel == NULL)
return SSH_ERROR;
rc = ssh_channel_open_session(channel);
if (rc != SSH_OK)
{
ssh_channel_free(channel);
return rc;
}
rc = ssh_channel_request_exec(channel, "/system scheduler add name=REBOOT interval=50s on-event=\"/system scheduler remove REBOOT;/system reboot\"");
if (rc != SSH_OK)
{
ssh_channel_close(channel);
ssh_channel_free(channel);
return rc;
}
nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
while (nbytes > 0)
{
if (write(1, buffer, nbytes) != (unsigned int) nbytes)
{
ssh_channel_close(channel);
ssh_channel_free(channel);
return SSH_ERROR;
}
nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
}
if (nbytes < 0)
{
ssh_channel_close(channel);
ssh_channel_free(channel);
return SSH_ERROR;
}
ssh_channel_send_eof(channel);
ssh_channel_close(channel);
ssh_channel_free(channel);
return SSH_OK;
}
int show_remote_ls(ssh_session session)
{
printf("inside show_remote_ls\n");
ssh_channel channel;
int rc;
char buffer[256];
unsigned int nbytes;
channel = ssh_channel_new(session);
if (channel == NULL)
return SSH_ERROR;
rc = ssh_channel_open_session(channel);
if (rc != SSH_OK)
{
ssh_channel_free(channel);
return rc;
}
char cmd[100];
strcpy(cmd,"ls ");
strcat(cmd,remotePath);
printf("cmd = %s\n", cmd);
rc = ssh_channel_request_exec(channel, cmd);
if (rc != SSH_OK)
{
ssh_channel_close(channel);
ssh_channel_free(channel);
return rc;
}
nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
while (nbytes > 0)
{
if (write(1, buffer, nbytes) != nbytes)
{
ssh_channel_close(channel);
ssh_channel_free(channel);
return SSH_ERROR;
}
nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
}
if (nbytes < 0)
{
ssh_channel_close(channel);
ssh_channel_free(channel);
return SSH_ERROR;
}
ssh_channel_send_eof(channel);
ssh_channel_close(channel);
ssh_channel_free(channel);
return SSH_OK;
}
/**
* @brief Close the scp channel.
*
* @param[in] scp The scp context to close.
*
* @return SSH_OK on success or an SSH error code.
*
* @see ssh_scp_init()
*/
int ssh_scp_close(ssh_scp scp)
{
char buffer[128];
int err;
if(scp==NULL)
return SSH_ERROR;
if(scp->channel != NULL){
if(ssh_channel_send_eof(scp->channel) == SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
/* avoid situations where data are buffered and
* not yet stored on disk. This can happen if the close is sent
* before we got the EOF back
*/
while(!ssh_channel_is_eof(scp->channel)){
err=ssh_channel_read(scp->channel,buffer,sizeof(buffer),0);
if(err==SSH_ERROR || err==0)
break;
}
if(ssh_channel_close(scp->channel) == SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
ssh_channel_free(scp->channel);
scp->channel=NULL;
}
scp->state=SSH_SCP_NEW;
return SSH_OK;
}
int close_client_channel(ssh_channel channel)
{
ssh_channel_send_eof(channel);
ssh_channel_close(channel);
ssh_channel_free(channel);
return SSH_OK;
}
/**
* Remove a channel from its associated port mapping structure
*
* Take the channel given and remove it from its parent port_map structure,
* closing it first and removing it from the fd_map in the gateway struct that
* maps client sockets -> channels.
*
* All channel pointers in pm->ch[] higher than this one are shifted down by
* one position and the array is shrunk appropriately.
*
* @cs channel structure to remove
* @return Nothing, if there are errors here they are either logged or the
* program exits (on malloc failure)
*/
void remove_channel_from_map(struct chan_sock *cs)
{
struct static_port_map *pm = cs->parent;
int i;
if(cs->parent == NULL)
log_exit(FATAL_ERROR, "Corrupt chan_sock parent %p->parent NULL", cs);
for(i = 0; i < pm->n_channels; i++) {
if(pm->ch[i] == cs) {
if( ssh_channel_is_open(cs->channel) &&
ssh_channel_close(cs->channel) != SSH_OK)
log_msg("Error on channel close for %s", pm->parent->name);
ssh_channel_free(cs->channel);
break;
}
}
debug("Destroy channel %p, closing fd=%d", cs->channel, cs->sock_fd);
for(; i < pm->n_channels - 1; i++)
pm->ch[i] = pm->ch[i + 1];
saferealloc((void **)&pm->ch, pm->n_channels * sizeof(cs),
"pm->channel realloc");
pm->n_channels -= 1;
close(cs->sock_fd);
/* Remove this fd from parent gw's fd_map */
remove_fdmap(pm->parent->chan_sock_fdmap, cs->sock_fd);
free(cs);
}
int SSH::openChannel()
{
int rc;
_logger->trace("Opening SSH channel");
if (_ssh == NULL)
{
_ssh = ssh_new();
}
_channel = ssh_channel_new(_ssh);
if (_channel == NULL)
{
_logger->error("Failed to open SSH channel");
throw SSHException("Failed to open SSH channel", SSHErrorCode::E_CHAN_OPEN_FAILED);
}
rc = ssh_channel_open_session(_channel);
if (rc != SSH_OK)
{
ssh_channel_close(_channel);
ssh_channel_free(_channel);
throw SSHException("Failed to open SSH session", SSHErrorCode::E_SESS_OPEN_FAILED);
}
_bChanOpen = true;
return SSHErrorCode::E_NOERR;
}
static ssh_channel pkd_channel_openreq_cb(ssh_session s,
void *userdata) {
ssh_channel c = NULL;
ssh_channel *out = (ssh_channel *) userdata;
/* assumes pubkey authentication has already succeeded */
pkdout("pkd_channel_openreq_cb\n");
c = ssh_channel_new(s);
if (c == NULL) {
pkderr("ssh_channel_new: %s\n", ssh_get_error(s));
return NULL;
}
ssh_callbacks_init(&pkd_channel_cb);
pkd_channel_cb.userdata = userdata;
if (ssh_set_channel_callbacks(c, &pkd_channel_cb) != SSH_OK) {
pkderr("ssh_set_channel_callbacks: %s\n", ssh_get_error(s));
ssh_channel_free(c);
c = NULL;
}
*out = c;
return c;
}
int SSHConnection::send(const std::string &data, std::ostream &result)
{
ssh_channel channel;
int rc;
char buffer[1024];
int nbytes;
channel = ssh_channel_new(session.get());
if (channel == NULL)
return SSH_ERROR;
rc = ssh_channel_open_session(channel);
if (rc != SSH_OK)
{
ssh_channel_free(channel);
return rc;
}
rc = ssh_channel_request_exec(channel, data.c_str());
if (rc != SSH_OK)
{
ssh_channel_close(channel);
ssh_channel_free(channel);
return rc;
}
nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
while (nbytes > 0)
{
if (write(1, buffer, nbytes) != (unsigned int) nbytes)
{
ssh_channel_close(channel);
ssh_channel_free(channel);
return SSH_ERROR;
}
nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
result.write(buffer, nbytes);
memset(buffer, 0, sizeof(buffer));
}
if (nbytes < 0)
{
ssh_channel_close(channel);
ssh_channel_free(channel);
return SSH_ERROR;
}
ssh_channel_send_eof(channel);
ssh_channel_close(channel);
ssh_channel_free(channel);
return SSH_OK;
}
/* TODO: make this function accept a ssh_channel */
ssh_channel ssh_message_channel_request_open_reply_accept(ssh_message msg) {
ssh_session session;
ssh_channel chan = NULL;
enter_function();
if (msg == NULL) {
leave_function();
return NULL;
}
session = msg->session;
chan = ssh_channel_new(session);
if (chan == NULL) {
leave_function();
return NULL;
}
chan->local_channel = ssh_channel_new_id(session);
chan->local_maxpacket = 35000;
chan->local_window = 32000;
chan->remote_channel = msg->channel_request_open.sender;
chan->remote_maxpacket = msg->channel_request_open.packet_size;
chan->remote_window = msg->channel_request_open.window;
chan->state = SSH_CHANNEL_STATE_OPEN;
if (buffer_add_u8(session->out_buffer, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION) < 0) {
goto error;
}
if (buffer_add_u32(session->out_buffer, htonl(chan->remote_channel)) < 0) {
goto error;
}
if (buffer_add_u32(session->out_buffer, htonl(chan->local_channel)) < 0) {
goto error;
}
if (buffer_add_u32(session->out_buffer, htonl(chan->local_window)) < 0) {
goto error;
}
if (buffer_add_u32(session->out_buffer, htonl(chan->local_maxpacket)) < 0) {
goto error;
}
ssh_log(session, SSH_LOG_PACKET,
"Accepting a channel request_open for chan %d", chan->remote_channel);
if (packet_send(session) == SSH_ERROR) {
goto error;
}
leave_function();
return chan;
error:
ssh_channel_free(chan);
leave_function();
return NULL;
}
void SSH::closeChannel()
{
if (_bChanOpen)
{
_bChanOpen = false;
ssh_channel_close(_channel);
ssh_channel_send_eof(_channel);
ssh_channel_free(_channel);
}
}
void clSSH::DoCloseChannel()
{
// Properly close the channel
if(m_channel) {
ssh_channel_close(m_channel);
ssh_channel_send_eof(m_channel);
ssh_channel_free(m_channel);
}
m_channel = NULL;
}
void Connector::logout () {
output->append("Logging out...") ;
if (channel != NULL) {
ssh_channel_close(channel);
ssh_channel_free(channel);
output->append("Channel is closed...") ;
}
ssh_disconnect(sshSession);
ssh_free (sshSession) ;
output->append("Logged out succesfully...") ;
}
void clSSHChannel::Close()
{
// Stop the worker thread
wxDELETE(m_readerThread);
if(IsOpen()) {
ssh_channel_close(m_channel);
ssh_channel_free(m_channel);
m_channel = NULL;
}
}
void ssh_scp_free(ssh_scp scp){
if(scp==NULL)
return;
if(scp->state != SSH_SCP_NEW)
ssh_scp_close(scp);
if(scp->channel)
ssh_channel_free(scp->channel);
SAFE_FREE(scp->location);
SAFE_FREE(scp->request_name);
SAFE_FREE(scp->warning);
SAFE_FREE(scp);
}
void server_handle_message(ssh_session s, ssh_message m, int type, int subtype, int *state)
{
int handled = 0;
if((*state == SERVER_CONNECTED) && (type == SSH_REQUEST_AUTH) && (subtype == SSH_AUTH_METHOD_PUBLICKEY))
{
ssh_public_key key = ssh_message_auth_publickey(m);
ssh_string keystr = publickey_to_string(key);
char *keyhash = pubkey_hash(keystr);
int has_sig = ssh_message_auth_publickey_state(m);
if(has_sig == SSH_PUBLICKEY_STATE_NONE)
{
if(authenticate(keyhash, 1))
{
//FIXME: type detection
ssh_string algostr = ssh_string_from_char("ssh-rsa");
ssh_message_auth_reply_pk_ok(m, algostr, keystr);
handled = 1;
ssh_string_free(algostr);
}
}
else if(has_sig == SSH_PUBLICKEY_STATE_VALID)
{
if(authenticate(keyhash, 0))
{
session_event(s, "authenticated", keyhash);
ssh_message_auth_reply_success(m, 0);
handled = 1;
*state = SERVER_AUTHENTICATED;
}
else
{
ssh_message_reply_default(m);
handled = 1;
*state = SERVER_CLOSED;
}
}
ssh_string_free(keystr);
free(keyhash);
}
else if((*state == SERVER_AUTHENTICATED) && (type == SSH_REQUEST_CHANNEL_OPEN) && (subtype == SSH_CHANNEL_SESSION))
{
ssh_channel chan = ssh_message_channel_request_open_reply_accept(m);
if(!chan)
session_error(s, "open-channel");
handled = 1;
session_event(s, "channel-opened", NULL);
channel_to_file(chan, 1);
ssh_channel_free(chan);
*state = SERVER_CLOSED;
}
if(!handled)
ssh_message_reply_default(m);
}
void session_free(psession_t p_session)
{
if(p_session->channel != NULL) {
ssh_channel_free(p_session->channel);
}
ssh_event_free(p_session->event);
ssh_free(p_session->session);
free(p_session);
return;
}
static void select_loop(ssh_session session,ssh_channel channel)
{
ssh_connector connector_in, connector_out, connector_err;
ssh_event event = ssh_event_new();
/* stdin */
connector_in = ssh_connector_new(session);
ssh_connector_set_out_channel(connector_in, channel, SSH_CONNECTOR_STDOUT);
/* Attach first endpointg of input pipe to SSH core */
ssh_connector_set_in_fd(connector_in, input_pipe[0] /* 0 */);
ssh_event_add_connector(event, connector_in);
/* stdout */
connector_out = ssh_connector_new(session);
#if defined(OUT_PIPE)
/* Attach first endpointg of output pipe to SSH core */
ssh_connector_set_out_fd(connector_out, output_pipe[0] /* 1*/);
#else
ssh_connector_set_out_fd(connector_out, 1);
#endif /* OUT_PIPE */
ssh_connector_set_in_channel(connector_out, channel, SSH_CONNECTOR_STDOUT);
ssh_event_add_connector(event, connector_out);
/* stderr */
connector_err = ssh_connector_new(session);
ssh_connector_set_out_fd(connector_err, 2);
ssh_connector_set_in_channel(connector_err, channel, SSH_CONNECTOR_STDERR);
ssh_event_add_connector(event, connector_err);
while(ssh_channel_is_open(channel))
{
if(signal_delayed)
sizechanged();
ssh_event_dopoll(event, 60000);
}
ssh_event_remove_connector(event, connector_in);
ssh_event_remove_connector(event, connector_out);
ssh_event_remove_connector(event, connector_err);
ssh_connector_free(connector_in);
ssh_connector_free(connector_out);
ssh_connector_free(connector_err);
ssh_event_free(event);
ssh_channel_free(channel);
}
static void ssh_cleanup(ssh_session sshs, ssh_channel channel)
{
if (channel) {
ssh_channel_send_eof(channel);
ssh_channel_close(channel);
ssh_channel_free(channel);
}
if (sshs) {
ssh_disconnect(sshs);
ssh_free(sshs);
}
}
void clSSHChannel::Open()
{
if(IsOpen()) { return; }
if(!m_ssh) { throw clException("ssh session is not opened"); }
m_channel = ssh_channel_new(m_ssh->GetSession());
if(!m_channel) { throw clException(BuildError("Failed to allocte ssh channel")); }
int rc = ssh_channel_open_session(m_channel);
if(rc != SSH_OK) {
ssh_channel_free(m_channel);
m_channel = NULL;
throw clException(BuildError("Failed to open ssh channel"));
}
}
static struct result exec_remote_command(char *this_command, ssh_session session)
{
ssh_channel channel;
int rc;
char buffer[256];
int nbytes;
channel = ssh_channel_new(session);
if (channel == NULL)
return (struct result){SSH_ERROR, NULL};
rc = ssh_channel_open_session(channel);
if (rc != SSH_OK) {
ssh_channel_free(channel);
return (struct result){rc, NULL};
}
ssh_channel open_client_channel(ssh_session session)
{
ssh_channel channel;
int rc;
channel = ssh_channel_new(session);
if (channel == NULL)
return NULL;
rc = ssh_channel_open_session(channel);
if (rc != SSH_OK)
{
ssh_channel_free(channel);
return NULL;
}
return (channel);
}
ssh_channel ssh_message_channel_request_open_reply_accept(ssh_message msg) {
ssh_channel chan;
int rc;
if (msg == NULL) {
return NULL;
}
chan = ssh_channel_new(msg->session);
if (chan == NULL) {
return NULL;
}
rc = ssh_message_channel_request_open_reply_accept_channel(msg, chan);
if (rc < 0) {
ssh_channel_free(chan);
chan = NULL;
}
return chan;
}
bool SSH_Socket::onExit()
{
std::cout << "SSH releasing channel" << std::endl;
if(sshChannel)
{
if (TheSocketHandler::Instance()->isActive())
ssh_channel_send_eof(sshChannel);
ssh_channel_close(sshChannel);
ssh_channel_free(sshChannel);
sshChannel = nullptr;
}
std::cout << "SSH releasing session" << std::endl;
if(session)
{
ssh_disconnect(session);
ssh_free(session);
session = nullptr;
}
return true;
}
static void do_cleanup(struct cleanup_node_struct **head_ref) {
struct cleanup_node_struct *current = (*head_ref);
struct cleanup_node_struct *previous = NULL, *gone = NULL;
while (current != NULL) {
if (ssh_channel_is_closed(current->data->channel)) {
if (current == (*head_ref)) {
(*head_ref) = current->next;
}
if (previous != NULL) {
previous->next = current->next;
}
gone = current;
current = current->next;
if (gone->data->channel) {
_close_socket(*gone->data);
ssh_remove_channel_callbacks(gone->data->channel, gone->data->cb_chan);
ssh_channel_free(gone->data->channel);
gone->data->channel = NULL;
SAFE_FREE(gone->data->p_fd);
SAFE_FREE(gone->data->cb_chan);
SAFE_FREE(gone->data);
SAFE_FREE(gone);
}
else {
fprintf(stderr, "channel already freed!\n");
}
_ssh_log(SSH_LOG_FUNCTIONS, "=== do_cleanup", "Freed.");
}
else {
ssh_channel_close(current->data->channel);
previous = current;
current = current->next;
}
}
}
static void torture_channel_read_error(void **state) {
struct torture_state *s = *state;
ssh_session session = s->ssh.session;
ssh_channel channel;
int rc;
int fd;
int i;
channel = ssh_channel_new(session);
assert_non_null(channel);
rc = ssh_channel_open_session(channel);
assert_ssh_return_code(session, rc);
rc = ssh_channel_request_exec(channel, "hexdump -C /dev/urandom");
assert_ssh_return_code(session, rc);
/* send crap and for server to send us a disconnect */
fd = ssh_get_fd(session);
assert_true(fd > 2);
rc = write(fd, "AAAA", 4);
assert_int_equal(rc, 4);
for (i=0;i<20;++i){
rc = ssh_channel_read(channel,buffer,sizeof(buffer),0);
if (rc == SSH_ERROR)
break;
}
#if OPENSSH_VERSION_MAJOR == 6 && OPENSSH_VERSION_MINOR >= 7
/* With openssh 6.7 this doesn't produce and error anymore */
assert_ssh_return_code(session, rc);
#else
assert_ssh_return_code_equal(session, rc, SSH_ERROR);
#endif
ssh_channel_free(channel);
}
static int
#else
static void
#endif
ptob_close (SCM channel)
{
struct channel_data *ch = _scm_to_channel_data (channel);
#if USING_GUILE_BEFORE_2_2
scm_port *pt = SCM_PTAB_ENTRY (channel);
ptob_flush (channel);
#endif
if (ch && ssh_channel_is_open (ch->ssh_channel))
{
_gssh_log_debug ("ptob_close", "closing and freeing the channel...",
channel);
ssh_channel_close (ch->ssh_channel);
ssh_channel_free (ch->ssh_channel);
_gssh_log_debug1 ("ptob_close", "closing and freeing the channel... done");
}
else
{
_gssh_log_debug1 ("ptob_close", "the channel is already freeed.");
}
SCM_SETSTREAM (channel, NULL);
#if USING_GUILE_BEFORE_2_2
scm_gc_free (pt->write_buf, pt->write_buf_size, "port write buffer");
scm_gc_free (pt->read_buf, pt->read_buf_size, "port read buffer");
return 0;
#endif
}
static ssh_channel run_capture(ssh_session sshs, const char* iface, const char* cfilter, const guint32 count)
{
char* cmdline = NULL;
ssh_channel channel;
int ret = 0;
channel = ssh_channel_new(sshs);
if (!channel)
return NULL;
if (ssh_channel_open_session(channel) != SSH_OK)
goto error;
if (ssh_channel_request_pty(channel) != SSH_OK)
goto error;
if (ssh_channel_change_pty_size(channel, 80, 24) != SSH_OK)
goto error;
if (ssh_channel_request_shell(channel) != SSH_OK)
goto error;
if (!check_ios_version(channel))
goto error;
if (ssh_channel_printf(channel, "terminal length 0\n") == EXIT_FAILURE)
goto error;
if (ssh_channel_printf(channel, "monitor capture buffer %s max-size 9500\n", WIRESHARK_CAPTURE_BUFFER) == EXIT_FAILURE)
goto error;
if (ssh_channel_printf(channel, "monitor capture buffer %s limit packet-count %u\n", WIRESHARK_CAPTURE_BUFFER, count) == EXIT_FAILURE)
goto error;
if (cfilter) {
gchar* multiline_filter;
gchar* chr;
if (ssh_channel_printf(channel, "configure terminal\n") == EXIT_FAILURE)
goto error;
if (ssh_channel_printf(channel, "ip access-list ex %s\n", WIRESHARK_CAPTURE_ACCESSLIST) == EXIT_FAILURE)
goto error;
multiline_filter = g_strdup(cfilter);
chr = multiline_filter;
while((chr = g_strstr_len(chr, strlen(chr), ",")) != NULL) {
chr[0] = '\n';
g_debug("Splitting filter into multiline");
}
ret = ssh_channel_write(channel, multiline_filter, (uint32_t)strlen(multiline_filter));
g_free(multiline_filter);
if (ret == SSH_ERROR)
goto error;
if (ssh_channel_printf(channel, "\nend\n") == EXIT_FAILURE)
goto error;
if (ssh_channel_printf(channel, "monitor capture buffer %s filter access-list %s\n",
WIRESHARK_CAPTURE_BUFFER, WIRESHARK_CAPTURE_ACCESSLIST) == EXIT_FAILURE)
goto error;
}
if (ssh_channel_printf(channel, "monitor capture point ip cef %s %s both\n", WIRESHARK_CAPTURE_POINT,
iface) == EXIT_FAILURE)
goto error;
if (ssh_channel_printf(channel, "monitor capture point associate %s %s \n", WIRESHARK_CAPTURE_POINT,
WIRESHARK_CAPTURE_BUFFER) == EXIT_FAILURE)
goto error;
if (ssh_channel_printf(channel, "monitor capture point start %s\n", WIRESHARK_CAPTURE_POINT) == EXIT_FAILURE)
goto error;
if (read_output_bytes(channel, -1, NULL) == EXIT_FAILURE)
goto error;
if (wait_until_data(channel, count) == EXIT_FAILURE)
goto error;
if (read_output_bytes(channel, -1, NULL) == EXIT_FAILURE)
goto error;
cmdline = g_strdup_printf("show monitor capture buffer %s dump\n", WIRESHARK_CAPTURE_BUFFER);
if (ssh_channel_printf(channel, cmdline) == EXIT_FAILURE)
goto error;
if (read_output_bytes(channel, (int)strlen(cmdline), NULL) == EXIT_FAILURE)
goto error;
g_free(cmdline);
return channel;
error:
g_free(cmdline);
g_warning("Error running ssh remote command");
read_output_bytes(channel, -1, NULL);
ssh_channel_close(channel);
ssh_channel_free(channel);
return NULL;
}