static void ssh_loop_read(ssh_channel channel, int fd)
{
int nbytes;
char buffer[SSH_READ_BLOCK_SIZE];
/* read from stdin until data are available */
do {
nbytes = ssh_channel_read(channel, buffer, SSH_READ_BLOCK_SIZE, 0);
if (write(fd, buffer, nbytes) != nbytes) {
errmsg_print("ERROR reading: %s\n", g_strerror(errno));
return;
}
} while(nbytes > 0);
/* read loop finished... maybe something wrong happened. Read from stderr */
do {
nbytes = ssh_channel_read(channel, buffer, SSH_READ_BLOCK_SIZE, 1);
if (write(STDERR_FILENO, buffer, nbytes) != nbytes) {
return;
}
} while(nbytes > 0);
if (ssh_channel_send_eof(channel) != SSH_OK)
return;
}
std::string SSH::execute(const std::string& command)
{
_logger->trace("Executing SSH command: %s", command);
int rc;
char buffer[1024];
int nbytes;
memset(buffer, 0, 1024);
if (_ssh == NULL)
{
_logger->debug("Initializing SSH");
_ssh = ssh_new();
}
if (_ssh == NULL) {
throw SubutaiException("Failed to start SSH session");
}
if (!_bChanOpen)
{
rc = openChannel();
if (rc != E_NOERR)
{
_logger->error("Couldn't open SSH channel: %d", rc);
return "";
}
}
_logger->trace("Starting SSH command execution");
rc = ssh_channel_request_exec(_channel, command.c_str());
if (rc != SSH_OK) {
closeChannel();
throw SSHException("Failed to execute SSH command", SSHErrorCode::E_CMD_EXEC_FAILED);
}
_logger->trace("Reading from channel");
nbytes = ssh_channel_read(_channel, buffer, sizeof(buffer), 0);
std::string pBuffer("");
while (nbytes > 0)
{
pBuffer.append(buffer);
nbytes = ssh_channel_read(_channel, buffer, sizeof(buffer), 0);
}
if (nbytes < 0)
{
closeChannel();
throw SSHException("Output channel is empty", SSHErrorCode::E_EMPTY_OUTPUT_CHAN);
}
closeChannel();
_logger->debug("SSH Execution output: %s", pBuffer);
return Poco::trim(pBuffer);
}
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;
}
void* Entry()
{
while(!TestDestroy()) {
// First, poll the channel
int bytes = ssh_channel_poll_timeout(m_channel, 500, 0);
if(bytes == SSH_ERROR) {
// an error
clCommandEvent event(wxEVT_SSH_CHANNEL_READ_ERROR);
m_handler->AddPendingEvent(event);
break;
} else if(bytes == SSH_EOF) {
clCommandEvent event(wxEVT_SSH_CHANNEL_CLOSED);
m_handler->AddPendingEvent(event);
break;
} else if(bytes == 0) {
continue;
} else {
// there is something to read
char* buffer = new char[bytes + 1];
if(ssh_channel_read(m_channel, buffer, bytes, 0) != bytes) {
clCommandEvent event(wxEVT_SSH_CHANNEL_READ_ERROR);
m_handler->AddPendingEvent(event);
wxDELETEA(buffer);
break;
} else {
buffer[bytes] = 0;
clCommandEvent event(wxEVT_SSH_CHANNEL_READ_OUTPUT);
event.SetString(wxString(buffer, wxConvUTF8));
m_handler->AddPendingEvent(event);
wxDELETEA(buffer);
}
}
}
return NULL;
}
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;
}
/**
* @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;
}
/**
* @brief Create a directory in a scp in sink mode.
*
* @param[in] scp The scp handle.
*
* @param[in] dirname The name of the directory being created.
*
* @param[in] mode The UNIX permissions for the new directory, e.g. 0755.
*
* @returns SSH_OK if the directory has been created, SSH_ERROR if
* an error occured.
*
* @see ssh_scp_leave_directory()
*/
int ssh_scp_push_directory(ssh_scp scp, const char *dirname, int mode){
char buffer[1024];
int r;
uint8_t code;
char *dir;
char *perms;
if(scp==NULL)
return SSH_ERROR;
if(scp->state != SSH_SCP_WRITE_INITED){
ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_push_directory called under invalid state");
return SSH_ERROR;
}
dir=ssh_basename(dirname);
perms=ssh_scp_string_mode(mode);
snprintf(buffer, sizeof(buffer), "D%s 0 %s\n", perms, dir);
SAFE_FREE(dir);
SAFE_FREE(perms);
r=ssh_channel_write(scp->channel,buffer,strlen(buffer));
if(r==SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
r=ssh_channel_read(scp->channel,&code,1,0);
if(r<=0){
ssh_set_error(scp->session,SSH_FATAL, "Error reading status code: %s",ssh_get_error(scp->session));
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
if(code != 0){
ssh_set_error(scp->session,SSH_FATAL, "scp status code %ud not valid", code);
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
return SSH_OK;
}
static size_t
read_from_channel_port (SCM channel, SCM dst, size_t start, size_t count)
#define FUNC_NAME "read_from_channel_port"
{
char *data = (char *) SCM_BYTEVECTOR_CONTENTS (dst) + start;
struct channel_data *cd = _scm_to_channel_data (channel);
int res;
if (! ssh_channel_is_open (cd->ssh_channel))
return 0;
/* Update state of the underlying channel and check whether we have
data to read or not. */
res = ssh_channel_poll (cd->ssh_channel, cd->is_stderr);
if (res == SSH_ERROR)
guile_ssh_error1 (FUNC_NAME, "Error polling channel", channel);
else if (res == SSH_EOF)
return 0;
/* Note: `ssh_channel_read' sometimes returns 0 even if `ssh_channel_poll'
returns a positive value. */
res = ssh_channel_read (cd->ssh_channel, data, count, cd->is_stderr);
if (res == SSH_AGAIN)
res = 0;
else if (res == SSH_ERROR)
guile_ssh_error1 (FUNC_NAME, "Error reading from the channel", channel);
assert (res >= 0);
return res;
}
/**
* @brief Leave a directory.
*
* @returns SSH_OK if the directory has been left,SSH_ERROR if an
* error occured.
*
* @see ssh_scp_push_directory()
*/
int ssh_scp_leave_directory(ssh_scp scp){
char buffer[]="E\n";
int r;
uint8_t code;
if(scp==NULL)
return SSH_ERROR;
if(scp->state != SSH_SCP_WRITE_INITED){
ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_leave_directory called under invalid state");
return SSH_ERROR;
}
r=ssh_channel_write(scp->channel,buffer,strlen(buffer));
if(r==SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
r=ssh_channel_read(scp->channel,&code,1,0);
if(r<=0){
ssh_set_error(scp->session,SSH_FATAL, "Error reading status code: %s",ssh_get_error(scp->session));
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
if(code != 0){
ssh_set_error(scp->session,SSH_FATAL, "scp status code %ud not valid", code);
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
return SSH_OK;
}
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;
}
/**
* @brief Initialize the scp channel.
*
* @param[in] scp The scp context to initialize.
*
* @return SSH_OK on success or an SSH error code.
*
* @see ssh_scp_new()
*/
int ssh_scp_init(ssh_scp scp)
{
int r;
char execbuffer[1024];
uint8_t code;
if(scp==NULL)
return SSH_ERROR;
if(scp->state != SSH_SCP_NEW){
ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_init called under invalid state");
return SSH_ERROR;
}
SSH_LOG(SSH_LOG_PROTOCOL,"Initializing scp session %s %son location '%s'",
scp->mode==SSH_SCP_WRITE?"write":"read",
scp->recursive?"recursive ":"",
scp->location);
scp->channel=ssh_channel_new(scp->session);
if(scp->channel == NULL){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
r= ssh_channel_open_session(scp->channel);
if(r==SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
if(scp->mode == SSH_SCP_WRITE)
snprintf(execbuffer,sizeof(execbuffer),"scp -t %s %s",
scp->recursive ? "-r":"", scp->location);
else
snprintf(execbuffer,sizeof(execbuffer),"scp -f %s %s",
scp->recursive ? "-r":"", scp->location);
if(ssh_channel_request_exec(scp->channel,execbuffer) == SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
if(scp->mode == SSH_SCP_WRITE){
r=ssh_channel_read(scp->channel,&code,1,0);
if(r<=0){
ssh_set_error(scp->session,SSH_FATAL, "Error reading status code: %s",ssh_get_error(scp->session));
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
if(code != 0){
ssh_set_error(scp->session,SSH_FATAL, "scp status code %ud not valid", code);
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
} else {
ssh_channel_write(scp->channel,"",1);
}
if(scp->mode == SSH_SCP_WRITE)
scp->state=SSH_SCP_WRITE_INITED;
else
scp->state=SSH_SCP_READ_INITED;
return SSH_OK;
}
static void torture_request_env(void **state)
{
struct torture_state *s = *state;
ssh_session session = s->ssh.session;
ssh_channel c;
char buffer[4096] = {0};
int nbytes;
int rc;
int lang_found = 0;
c = ssh_channel_new(session);
assert_non_null(c);
rc = ssh_channel_open_session(c);
assert_ssh_return_code(session, rc);
rc = ssh_channel_request_env(c, "LC_LIBSSH", "LIBSSH_EXPORTED_VARIABLE");
assert_ssh_return_code(session, rc);
rc = ssh_channel_request_exec(c, "echo $LC_LIBSSH");
assert_ssh_return_code(session, rc);
nbytes = ssh_channel_read(c, buffer, sizeof(buffer) - 1, 0);
printf("nbytes=%d\n", nbytes);
while (nbytes > 0) {
#if 1
rc = fwrite(buffer, 1, nbytes, stdout);
assert_int_equal(rc, nbytes);
#endif
buffer[nbytes]='\0';
if (strstr(buffer, "LIBSSH_EXPORTED_VARIABLE")) {
lang_found = 1;
break;
}
nbytes = ssh_channel_read(c, buffer, sizeof(buffer), 0);
}
assert_int_equal(lang_found, 1);
ssh_channel_close(c);
}
/**
* @brief Write into a remote scp file.
*
* @param[in] scp The scp handle.
*
* @param[in] buffer The buffer to write.
*
* @param[in] len The number of bytes to write.
*
* @returns SSH_OK if the write was successful, SSH_ERROR an error
* occured while writing.
*/
int ssh_scp_write(ssh_scp scp, const void *buffer, size_t len){
int w;
int r;
uint8_t code;
if(scp==NULL)
return SSH_ERROR;
if(scp->state != SSH_SCP_WRITE_WRITING){
ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_write called under invalid state");
return SSH_ERROR;
}
if(scp->processed + len > scp->filelen)
len = (size_t) (scp->filelen - scp->processed);
/* hack to avoid waiting for window change */
r = ssh_channel_poll(scp->channel, 0);
if (r == SSH_ERROR) {
scp->state = SSH_SCP_ERROR;
return SSH_ERROR;
}
w=ssh_channel_write(scp->channel,buffer,len);
if(w != SSH_ERROR)
scp->processed += w;
else {
scp->state=SSH_SCP_ERROR;
//return=channel_get_exit_status(scp->channel);
return SSH_ERROR;
}
/* Far end sometimes send a status message, which we need to read
* and handle */
r = ssh_channel_poll(scp->channel,0);
if(r > 0){
r = ssh_channel_read(scp->channel, &code, 1, 0);
if(r == SSH_ERROR){
return SSH_ERROR;
}
if(code == 1 || code == 2){
ssh_set_error(scp->session,SSH_REQUEST_DENIED, "SCP: Error: status code %i received", code);
return SSH_ERROR;
}
}
/* Check if we arrived at end of file */
if(scp->processed == scp->filelen) {
code = 0;
w = ssh_channel_write(scp->channel, &code, 1);
if(w == SSH_ERROR){
scp->state = SSH_SCP_ERROR;
return SSH_ERROR;
}
scp->processed=scp->filelen=0;
scp->state=SSH_SCP_WRITE_INITED;
}
return SSH_OK;
}
static void torture_request_env(void **state)
{
ssh_session session = *state;
ssh_channel c;
char buffer[4096] = {0};
int nbytes;
int rc;
int lang_found = 0;
c = ssh_channel_new(session);
assert_non_null(c);
rc = ssh_channel_open_session(c);
assert_int_equal(rc, SSH_OK);
rc = ssh_channel_request_env(c, "LC_LIBSSH", "LIBSSH");
assert_int_equal(rc, SSH_OK);
rc = ssh_channel_request_exec(c, "bash -c export");
assert_int_equal(rc, SSH_OK);
nbytes = ssh_channel_read(c, buffer, sizeof(buffer) - 1, 0);
while (nbytes > 0) {
#if 0
rc = fwrite(buffer, 1, nbytes, stdout);
assert_int_equal(rc, nbytes);
#endif
buffer[nbytes]='\0';
if (strstr(buffer, "LC_LIBSSH=\"LIBSSH\"")) {
lang_found = 1;
break;
}
nbytes = ssh_channel_read(c, buffer, sizeof(buffer), 0);
}
assert_int_equal(lang_found, 1);
ssh_channel_close(c);
}
static void torture_channel_read_error(void **state) {
ssh_session session = *state;
char *user = getenv("TORTURE_USER");
ssh_channel channel;
int rc;
int i;
if (user == NULL) {
print_message("*** Please set the environment variable TORTURE_USER"
" to enable this test!!\n");
return;
}
rc = ssh_options_set(session, SSH_OPTIONS_USER, user);
assert_true(rc == SSH_OK);
rc = ssh_connect(session);
assert_true(rc == SSH_OK);
rc = ssh_userauth_none(session,NULL);
/* This request should return a SSH_REQUEST_DENIED error */
if (rc == SSH_ERROR) {
assert_true(ssh_get_error_code(session) == SSH_REQUEST_DENIED);
}
assert_true(ssh_auth_list(session) & SSH_AUTH_METHOD_PUBLICKEY);
rc = ssh_userauth_autopubkey(session, NULL);
assert_true(rc == SSH_AUTH_SUCCESS);
channel = ssh_channel_new(session);
assert_true(channel != NULL);
rc = ssh_channel_open_session(channel);
assert_true(rc == SSH_OK);
rc = ssh_channel_request_exec(channel, "hexdump -C /dev/urandom");
assert_true(rc == SSH_OK);
/* send crap and for server to send us a disconnect */
rc = write(ssh_get_fd(session),"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;
}
assert_true(rc == SSH_ERROR);
}
/** @brief Read from a remote scp file
* @param[in] scp The scp handle.
*
* @param[in] buffer The destination buffer.
*
* @param[in] size The size of the buffer.
*
* @returns The nNumber of bytes read, SSH_ERROR if an error occured
* while reading.
*/
int ssh_scp_read(ssh_scp scp, void *buffer, size_t size){
int r;
int code;
if(scp==NULL)
return SSH_ERROR;
if(scp->state == SSH_SCP_READ_REQUESTED && scp->request_type == SSH_SCP_REQUEST_NEWFILE){
r=ssh_scp_accept_request(scp);
if(r==SSH_ERROR)
return r;
}
if(scp->state != SSH_SCP_READ_READING){
ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_read called under invalid state");
return SSH_ERROR;
}
if(scp->processed + size > scp->filelen)
size = (size_t) (scp->filelen - scp->processed);
if(size > 65536)
size=65536; /* avoid too large reads */
r=ssh_channel_read(scp->channel,buffer,size,0);
if(r != SSH_ERROR)
scp->processed += r;
else {
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
/* Check if we arrived at end of file */
if(scp->processed == scp->filelen) {
scp->processed=scp->filelen=0;
ssh_channel_write(scp->channel,"",1);
code=ssh_scp_response(scp,NULL);
if(code == 0){
scp->state=SSH_SCP_READ_INITED;
return r;
}
if(code==1){
scp->state=SSH_SCP_READ_INITED;
return SSH_ERROR;
}
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
return r;
}
/**
* @brief Read a string on a channel, terminated by '\n'
*
* @param[in] scp The scp handle.
*
* @param[out] buffer A pointer to a buffer to place the string.
*
* @param[in] len The size of the buffer in bytes. If the string is bigger
* than len-1, only len-1 bytes are read and the string is
* null-terminated.
*
* @returns SSH_OK if the string was read, SSH_ERROR if an error
* occured while reading.
*/
int ssh_scp_read_string(ssh_scp scp, char *buffer, size_t len){
size_t r=0;
int err=SSH_OK;
if(scp==NULL)
return SSH_ERROR;
while(r<len-1){
err=ssh_channel_read(scp->channel,&buffer[r],1,0);
if(err==SSH_ERROR){
break;
}
if(err==0){
ssh_set_error(scp->session,SSH_FATAL,"End of file while reading string");
err=SSH_ERROR;
break;
}
r++;
if(buffer[r-1] == '\n')
break;
}
buffer[r]=0;
return err;
}
/**
* @brief Initialize the sending of a file to a scp in sink mode, using a 64-bit size.
*
* @param[in] scp The scp handle.
*
* @param[in] filename The name of the file being sent. It should not contain
* any path indicator
*
* @param[in] size Exact size in bytes of the file being sent.
*
* @param[in] mode The UNIX permissions for the new file, e.g. 0644.
*
* @returns SSH_OK if the file is ready to be sent, SSH_ERROR if an
* error occured.
*
* @see ssh_scp_push_file()
*/
int ssh_scp_push_file64(ssh_scp scp, const char *filename, uint64_t size, int mode){
char buffer[1024];
int r;
uint8_t code;
char *file;
char *perms;
if(scp==NULL)
return SSH_ERROR;
if(scp->state != SSH_SCP_WRITE_INITED){
ssh_set_error(scp->session,SSH_FATAL,"ssh_scp_push_file called under invalid state");
return SSH_ERROR;
}
file=ssh_basename(filename);
perms=ssh_scp_string_mode(mode);
SSH_LOG(SSH_LOG_PROTOCOL,"SCP pushing file %s, size %" PRIu64 " with permissions '%s'",file,size,perms);
snprintf(buffer, sizeof(buffer), "C%s %" PRIu64 " %s\n", perms, size, file);
SAFE_FREE(file);
SAFE_FREE(perms);
r=ssh_channel_write(scp->channel,buffer,strlen(buffer));
if(r==SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
r=ssh_channel_read(scp->channel,&code,1,0);
if(r<=0){
ssh_set_error(scp->session,SSH_FATAL, "Error reading status code: %s",ssh_get_error(scp->session));
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
if(code != 0){
ssh_set_error(scp->session,SSH_FATAL, "scp status code %ud not valid", code);
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
scp->filelen = size;
scp->processed = 0;
scp->state=SSH_SCP_WRITE_WRITING;
return SSH_OK;
}
/* Read data from the channel. Return EOF if no data is available or
throw `guile-ssh-error' if an error occured. */
static int
ptob_fill_input (SCM channel)
#define FUNC_NAME "ptob_fill_input"
{
struct channel_data *cd = _scm_to_channel_data (channel);
scm_port *pt = SCM_PTAB_ENTRY (channel);
int res;
if (! ssh_channel_is_open (cd->ssh_channel))
return EOF;
/* Update state of the underlying channel and check whether we have
data to read or not. */
res = ssh_channel_poll (cd->ssh_channel, cd->is_stderr);
if (res == SSH_ERROR)
guile_ssh_error1 (FUNC_NAME, "Error polling channel", channel);
else if (res == SSH_EOF)
return EOF;
res = ssh_channel_read (cd->ssh_channel,
pt->read_buf, pt->read_buf_size,
cd->is_stderr);
if (res == SSH_ERROR)
guile_ssh_error1 (FUNC_NAME, "Error reading from the channel", channel);
/* `ssh_channel_read' sometimes returns 0 even if `ssh_channel_poll' returns
a positive value. So we must ensure that res != 0 otherwise an assertion
in `scm_i_fill_input' won't be meet (see `ports.c' in Guile 2.0.9). */
if ((! res) || (res == SSH_AGAIN))
return EOF;
pt->read_pos = pt->read_buf;
pt->read_end = pt->read_buf + res;
return *pt->read_buf;
}
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);
}
/**
* @internal
*
* @brief Wait for a response of the scp server.
*
* @param[in] scp The scp handle.
*
* @param[out] response A pointer where the response message must be copied if
* any. This pointer must then be free'd.
*
* @returns The return code, SSH_ERROR a error occured.
*/
int ssh_scp_response(ssh_scp scp, char **response){
unsigned char code;
int r;
char msg[128];
if(scp==NULL)
return SSH_ERROR;
r=ssh_channel_read(scp->channel,&code,1,0);
if(r == SSH_ERROR)
return SSH_ERROR;
if(code == 0)
return 0;
if(code > 2){
ssh_set_error(scp->session,SSH_FATAL, "SCP: invalid status code %ud received", code);
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
r=ssh_scp_read_string(scp,msg,sizeof(msg));
if(r==SSH_ERROR)
return r;
/* Warning */
if(code == 1){
ssh_set_error(scp->session,SSH_REQUEST_DENIED, "SCP: Warning: status code 1 received: %s", msg);
SSH_LOG(SSH_LOG_RARE,"SCP: Warning: status code 1 received: %s", msg);
if(response)
*response=strdup(msg);
return 1;
}
if(code == 2){
ssh_set_error(scp->session,SSH_FATAL, "SCP: Error: status code 2 received: %s", msg);
if(response)
*response=strdup(msg);
return 2;
}
/* Not reached */
return SSH_ERROR;
}
int SSHThread( void *data )
{
// TODO: Hogne was here, disabling this problem child.. :)
return 0;
#ifdef ENABLE_SSH
ssh_session session = NULL;
ssh_bind sshbind = NULL;
ssh_event mainloop;
struct ssh_server_callbacks_struct cb = {
.userdata = NULL,
.auth_password_function = auth_password,
.auth_gssapi_mic_function = auth_gssapi_mic,
.channel_open_request_session_function = new_session_channel
};
char buf[2048];
int i;
int r;
DEBUG("Starting SSH Process\n");
SSHServer *ts = (SSHServer *)data;
if( !ts ) return 0;
ts->sshs_FriendHome = getenv( "FRIEND_HOME" );
int len = strlen( ts->sshs_FriendHome );
ts->sshs_RSAKeyHome = calloc( len+64, sizeof(char) );
ts->sshs_DSAKeyHome = calloc( len+64, sizeof(char) );
strcpy( ts->sshs_RSAKeyHome, ts->sshs_FriendHome );
strcpy( ts->sshs_DSAKeyHome, ts->sshs_FriendHome );
strcat( ts->sshs_RSAKeyHome, "keys/ssh_host_rsa_key" );
strcat( ts->sshs_DSAKeyHome, "keys/ssh_host_dsa_key" );
//DEBUG("SSH sshs_RSAKeyHome set to %s\n", ts->sshs_RSAKeyHome );
sshbind = ssh_bind_new();
BOOL welcomeMessage = FALSE;
ssh_bind_options_set( sshbind, SSH_BIND_OPTIONS_DSAKEY, ts->sshs_DSAKeyHome );
ssh_bind_options_set( sshbind, SSH_BIND_OPTIONS_RSAKEY, ts->sshs_RSAKeyHome );
//ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_HOSTKEY, arg);
//DEBUG("IMPORT RSA KEY %s\n", ts->sshs_RSAKeyHome );
ssh_bind_options_set( sshbind, SSH_BIND_OPTIONS_BINDPORT_STR, SSH_SERVER_PORT );
//verbose
ssh_bind_options_set( sshbind, SSH_BIND_OPTIONS_LOG_VERBOSITY_STR, "2" );
ssh_bind_options_set( sshbind, SSH_BIND_OPTIONS_BINDADDR, "127.0.0.1" );
if( ts->sshs_RSAKeyHome ) free( ts->sshs_RSAKeyHome );
if( ts->sshs_DSAKeyHome ) free( ts->sshs_DSAKeyHome );
// TODO: ts->sshs_Quit sometimes can not be read!
while( ts != NULL && !ts->sshs_Quit )
{
DEBUG("Server options set\n");
#ifdef WITH_PCAP
set_pcap(session);
#endif
DEBUG("Server before bind\n");
if( ssh_bind_listen( sshbind )<0 )
{
ERROR("Error listening to socket: %s\n",ssh_get_error(sshbind) );
break;
}
DEBUG("Server before accept\n");
session=ssh_new();
r = ssh_bind_accept( sshbind , session );
if( r==SSH_ERROR )
{
ERROR("error accepting a connection : %s\n",ssh_get_error(sshbind));
break;
}
ssh_callbacks_init( &cb );
SSHSession *sess = calloc( 1, sizeof( SSHSession ) );
sess->sshs_Session = session;
cb.userdata = sess;
DEBUG("User data set\n");
ssh_set_server_callbacks( session, &cb );
if ( ssh_handle_key_exchange( session ) )
{
ERROR("ssh_handle_key_exchange: %s\n", ssh_get_error(session));
continue;
//goto disconnect;
}
DEBUG("Connection accepted\n");
ssh_set_auth_methods( session,SSH_AUTH_METHOD_PASSWORD | SSH_AUTH_METHOD_GSSAPI_MIC );
//
// New session/connection put it into thread
//
switch( fork() )
{
case 0:
// Remove the SIGCHLD handler inherited from parent
signal(SIGCHLD, SIG_DFL);
mainloop = ssh_event_new();
ssh_event_add_session( mainloop, session );
while( !(sess->sshs_Authenticated && sess->sshs_Chan != NULL) )
{
if( sess->sshs_Error )
{
ERROR("SSHSession error %d\n", sess->sshs_Error );
break;
}
r = ssh_event_dopoll( mainloop, -1 );
if( r == SSH_ERROR )
{
ERROR("Error : %s\n",ssh_get_error( session ) );
ssh_disconnect( session );
return 1;
}
strcpy( buf, "------------------------------------------------------\n\r" \
"--- Welcome in FC server, use help to work with me ---\n\r" \
"------------------------------------------------------\n\r" );
ssh_channel_write( sess->sshs_Chan, buf, strlen( buf ) );
if( sess->sshs_Path == NULL )
{
sess->sshs_Path = calloc( 1024, sizeof(char) );
sess->sshs_DispText = calloc( 1024+48, sizeof(char) );
}
strcpy( sess->sshs_Path, "/" );
if( sess->sshs_Usr )
{
sprintf( sess->sshs_DispText, "%s:%s ", sess->sshs_Usr->u_Name, sess->sshs_Path );
}else{
sprintf( sess->sshs_DispText, ":%s ", sess->sshs_Path );
}
int i = 0;
do
{
ssh_channel_write( sess->sshs_Chan, sess->sshs_DispText, strlen( sess->sshs_DispText ) );
i = ssh_channel_read( sess->sshs_Chan, buf, 2048, 0 );
if( i > 0 )
{
DEBUG("READING FROM CHANNEL %d - size %d %d %c -n %d\n", i, strlen( buf ), buf[0], buf[0], '\n' );
//ssh_channel_write( sess->sshs_Chan, buf, 1 );
handleSSHCommands( sess, buf, i );
}
if( sess->sshs_Quit )
{
break;
}
}
while( i>0 );
if( sess->sshs_Quit )
break;
}
DEBUG("Closing ssh connection\n");
ssh_event_free( mainloop );
ssh_disconnect( session );
ssh_free( session );
if( sess->sshs_DispText )
{
FFree( sess->sshs_DispText );
}
if( sess->sshs_Path )
{
FFree( sess->sshs_Path );
}
DEBUG("Connection released\n");
FFree( sess );
abort();
DEBUG("AUTH\n");
break;
case -1:
ERROR("Cannot create fork!\n");
break;
}
#ifdef WITH_PCAP
cleanup_pcap();
#endif
} // main loop
disconnect:
DEBUG("DISCONNECTED\n");
#endif // ENABLE_SSH
return 0;
}
int main(int argc, char **argv){
ssh_session session;
ssh_bind sshbind;
ssh_message message;
ssh_channel chan=0;
char buf[2048];
int auth=0;
int shell=0;
int i;
int r;
sshbind=ssh_bind_new();
session=ssh_new();
ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_DSAKEY,
KEYS_FOLDER "ssh_host_dsa_key");
ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_RSAKEY,
KEYS_FOLDER "ssh_host_rsa_key");
#ifdef HAVE_ARGP_H
/*
* Parse our arguments; every option seen by parse_opt will
* be reflected in arguments.
*/
argp_parse (&argp, argc, argv, 0, 0, sshbind);
#else
(void) argc;
(void) argv;
#endif
#ifdef WITH_PCAP
set_pcap(session);
#endif
if(ssh_bind_listen(sshbind)<0){
printf("Error listening to socket: %s\n", ssh_get_error(sshbind));
return 1;
}
printf("Started sample libssh sshd on port %d\n", port);
printf("You can login as the user %s with the password %s\n", SSHD_USER,
SSHD_PASSWORD);
r = ssh_bind_accept(sshbind, session);
if(r==SSH_ERROR){
printf("Error accepting a connection: %s\n", ssh_get_error(sshbind));
return 1;
}
if (ssh_handle_key_exchange(session)) {
printf("ssh_handle_key_exchange: %s\n", ssh_get_error(session));
return 1;
}
/* proceed to authentication */
auth = authenticate(session);
if (!auth || !authenticated) {
printf("Authentication error: %s\n", ssh_get_error(session));
ssh_disconnect(session);
return 1;
}
/* wait for a channel session */
do {
message = ssh_message_get(session);
if(message){
if(ssh_message_type(message) == SSH_REQUEST_CHANNEL_OPEN &&
ssh_message_subtype(message) == SSH_CHANNEL_SESSION) {
chan = ssh_message_channel_request_open_reply_accept(message);
ssh_message_free(message);
break;
} else {
ssh_message_reply_default(message);
ssh_message_free(message);
}
} else {
break;
}
} while(!chan);
if(!chan) {
printf("Error: cleint did not ask for a channel session (%s)\n",
ssh_get_error(session));
ssh_finalize();
return 1;
}
/* wait for a shell */
do {
message = ssh_message_get(session);
if(message != NULL) {
if(ssh_message_type(message) == SSH_REQUEST_CHANNEL &&
ssh_message_subtype(message) == SSH_CHANNEL_REQUEST_SHELL) {
shell = 1;
ssh_message_channel_request_reply_success(message);
ssh_message_free(message);
break;
}
ssh_message_reply_default(message);
ssh_message_free(message);
} else {
break;
}
} while(!shell);
if(!shell) {
printf("Error: No shell requested (%s)\n", ssh_get_error(session));
return 1;
}
printf("it works !\n");
do{
i=ssh_channel_read(chan,buf, 2048, 0);
if(i>0) {
if(*buf == '' || *buf == '')
break;
if(i == 1 && *buf == '\r')
ssh_channel_write(chan, "\r\n", 2);
else
ssh_channel_write(chan, buf, i);
if (write(1,buf,i) < 0) {
printf("error writing to buffer\n");
return 1;
}
}
} while (i>0);
ssh_channel_close(chan);
ssh_disconnect(session);
ssh_bind_free(sshbind);
#ifdef WITH_PCAP
cleanup_pcap();
#endif
ssh_finalize();
return 0;
}
int main(int argc, char **argv)
{
int verbose = SSH_LOG_PROTOCOL;
int port = 22;
int rc = 0;
char *username = "******";
char *passwd = "2113";
ssh_session my_ssh_session = ssh_new();
if (my_ssh_session == NULL)
exit(-1);
ssh_options_set(my_ssh_session, SSH_OPTIONS_HOST, "localhost");
ssh_options_set(my_ssh_session, SSH_OPTIONS_LOG_VERBOSITY, &verbose);
ssh_options_set(my_ssh_session, SSH_OPTIONS_PORT, &port);
rc = ssh_connect(my_ssh_session);
printf("conn: ok=?%d, %d, %s\n", rc==SSH_OK, rc, ssh_get_error(my_ssh_session));
rc = ssh_userauth_password(my_ssh_session, username, passwd);
printf("conn: ok=?%d, %d, %s\n", rc==SSH_OK, rc, ssh_get_error(my_ssh_session));
ssh_channel channel;
channel = ssh_channel_new(my_ssh_session);
if (channel == NULL) {
}
rc = ssh_channel_open_session(channel);
printf("conn: ok=?%d, %d, %s\n", rc==SSH_OK, rc, ssh_get_error(my_ssh_session));
rc = ssh_channel_request_exec(channel, "ls -lh");
printf("conn: ok=?%d, %d, %s\n", rc==SSH_OK, rc, ssh_get_error(my_ssh_session));
char buffer[100];
unsigned int nbytes;
nbytes = ssh_channel_read(channel, buffer, sizeof(buffer)-1, 0);
buffer[nbytes] = '\0';
printf("ssh out byte: %d, %s\n", nbytes, buffer);
while (nbytes > 0) {
nbytes = ssh_channel_read(channel, buffer, sizeof(buffer)-1, 0);
buffer[nbytes] = '\0';
printf("ssh out byte: %d, %s\n", nbytes, buffer);
}
nbytes = ssh_channel_read(channel, buffer, sizeof(buffer)-1, 1);
buffer[nbytes] = '\0';
printf("ssh err byte: %d, %s\n", nbytes, buffer);
while (nbytes > 0) {
nbytes = ssh_channel_read(channel, buffer, sizeof(buffer)-1, 1);
buffer[nbytes] = '\0';
printf("ssh err byte: %d, %s\n", nbytes, buffer);
}
ssh_channel_send_eof(channel);
ssh_channel_close(channel);
ssh_channel_free(channel);
ssh_disconnect(my_ssh_session);
ssh_free(my_ssh_session);
return 0;
}
int main(int argc, char **argv){
ssh_session session;
ssh_bind sshbind;
ssh_event mainloop;
struct ssh_server_callbacks_struct cb = {
.userdata = NULL,
.auth_password_function = auth_password,
.auth_gssapi_mic_function = auth_gssapi_mic,
.channel_open_request_session_function = new_session_channel
};
char buf[2048];
int sftp=0;
int i;
int r;
sshbind=ssh_bind_new();
session=ssh_new();
ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_DSAKEY, KEYS_FOLDER "ssh_host_dsa_key");
ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_RSAKEY, KEYS_FOLDER "ssh_host_rsa_key");
#ifdef HAVE_ARGP_H
/*
* Parse our arguments; every option seen by parse_opt will
* be reflected in arguments.
*/
argp_parse (&argp, argc, argv, 0, 0, sshbind);
#else
(void) argc;
(void) argv;
#endif
if(ssh_bind_listen(sshbind)<0){
printf("Error listening to socket: %s\n",ssh_get_error(sshbind));
return 1;
}
r=ssh_bind_accept(sshbind,session);
if(r==SSH_ERROR){
printf("error accepting a connection : %s\n",ssh_get_error(sshbind));
return 1;
}
ssh_callbacks_init(&cb);
ssh_set_server_callbacks(session, &cb);
if (ssh_handle_key_exchange(session)) {
printf("ssh_handle_key_exchange: %s\n", ssh_get_error(session));
return 1;
}
ssh_set_auth_methods(session,SSH_AUTH_METHOD_PASSWORD | SSH_AUTH_METHOD_GSSAPI_MIC);
mainloop = ssh_event_new();
ssh_event_add_session(mainloop, session);
while (!(authenticated && chan != NULL)){
if(error)
break;
r = ssh_event_dopoll(mainloop, -1);
if (r == SSH_ERROR){
printf("Error : %s\n",ssh_get_error(session));
ssh_disconnect(session);
return 1;
}
}
if(error){
printf("Error, exiting loop\n");
} else
printf("Authenticated and got a channel\n");
do{
i=ssh_channel_read(chan,buf, 2048, 0);
if(i>0) {
ssh_channel_write(chan, buf, i);
if (write(1,buf,i) < 0) {
printf("error writing to buffer\n");
return 1;
}
if (buf[0] == '\x0d') {
if (write(1, "\n", 1) < 0) {
printf("error writing to buffer\n");
return 1;
}
ssh_channel_write(chan, "\n", 1);
}
}
} while (i>0);
ssh_disconnect(session);
ssh_bind_free(sshbind);
ssh_finalize();
return 0;
}
int Connector::startVNCSession(string hours, string minutes, string seconds) {
std::string command = "/usr/sara/bin/rvs_vnc " + m_hours + ":" + m_minutes + ":" + m_seconds ;
// creates a new channel
channel = ssh_channel_new(sshSession);
if (channel == NULL) {
output->append("ERROR: Unable to set up channel between host and client...") ;
exit(-1) ;
}
// links the channel to the current ssh session
int response = ssh_channel_open_session(channel);
if (response != SSH_OK) {
ssh_channel_free(channel);
output->append("ERROR: Unable to set up channel between host and client...") ;
exit(-1) ;
}
// Executes the command
output->append("A new channel has been opened.") ;
response = ssh_channel_request_exec(channel, command.c_str());
if (response != SSH_OK){
output->append("ERROR: Unable to execute the command on the host...") ;
exit(-1) ;
}
// Reading the result of the command and printing it to the status bar
char buffer[8192];
unsigned int nbytes;
nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
while (nbytes > 0)
{
if (fwrite(buffer, 1, nbytes, stdout) != nbytes)
{
ssh_channel_close(channel);
ssh_channel_free(channel);
output->append("ERROR: buffer to small to read all data") ;
break ;
}
nbytes = ssh_channel_read(channel, buffer, sizeof(buffer), 0);
}
if (nbytes < 0)
{
ssh_channel_close(channel);
ssh_channel_free(channel);
output->append("ERROR: buffer to small to read all data") ;
}
/*Check whether the new VNC session is queued */
std::string bufferOutput = buffer ;
size_t found = bufferOutput.find("v42-") ;
std::string strNode (bufferOutput, found + 4, 2) ;
QString strNode2 = QString::fromStdString(strNode) ;
QString status = QString("Connection to node %1").arg(strNode2) ;
output->append(status) ;
int node = atoi(strNode.c_str());
//int node = strNode.toInt() ;
// Closes the channel
ssh_channel_send_eof(channel);
ssh_channel_close(channel);
output->append("Loading VNC session...") ;
qApp->processEvents() ;
return node ;
}
}
return 0;
case 0:
/* read returns 0 on end-of-file */
errno = do_read ? 0 : EPIPE;
return pos;
default:
pos += (size_t) res;
}
}
return pos;
} else {
/* using an SSH channel */
while (n > pos){
if (do_read)
res = ssh_channel_read(channel,b + pos, n-pos, 0);
else
res = ssh_channel_write(channel, b+pos, n-pos);
if (res == SSH_AGAIN)
continue;
if (res == SSH_ERROR)
return 0;
pos += (size_t)res;
}
return pos;
}
}
ssh_agent ssh_agent_new(struct ssh_session_struct *session) {
ssh_agent agent = NULL;
int main(int argc, char **argv){
ssh_session session;
ssh_bind sshbind;
ssh_message message;
ssh_channel chan=0;
char buf[2048];
int auth=0;
int sftp=0;
int i;
int r;
sshbind=ssh_bind_new();
session=ssh_new();
ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_DSAKEY, KEYS_FOLDER "ssh_host_dsa_key");
ssh_bind_options_set(sshbind, SSH_BIND_OPTIONS_RSAKEY, KEYS_FOLDER "ssh_host_rsa_key");
#ifdef HAVE_ARGP_H
/*
* Parse our arguments; every option seen by parse_opt will
* be reflected in arguments.
*/
argp_parse (&argp, argc, argv, 0, 0, sshbind);
#else
(void) argc;
(void) argv;
#endif
#ifdef WITH_PCAP
set_pcap(session);
#endif
if(ssh_bind_listen(sshbind)<0){
printf("Error listening to socket: %s\n",ssh_get_error(sshbind));
return 1;
}
r=ssh_bind_accept(sshbind,session);
if(r==SSH_ERROR){
printf("error accepting a connection : %s\n",ssh_get_error(sshbind));
return 1;
}
if (ssh_handle_key_exchange(session)) {
printf("ssh_handle_key_exchange: %s\n", ssh_get_error(session));
return 1;
}
do {
message=ssh_message_get(session);
if(!message)
break;
switch(ssh_message_type(message)){
case SSH_REQUEST_AUTH:
switch(ssh_message_subtype(message)){
case SSH_AUTH_METHOD_PASSWORD:
printf("User %s wants to auth with pass %s\n",
ssh_message_auth_user(message),
ssh_message_auth_password(message));
if(auth_password(ssh_message_auth_user(message),
ssh_message_auth_password(message))){
auth=1;
ssh_message_auth_reply_success(message,0);
break;
}
// not authenticated, send default message
case SSH_AUTH_METHOD_NONE:
default:
ssh_message_auth_set_methods(message,SSH_AUTH_METHOD_PASSWORD);
ssh_message_reply_default(message);
break;
}
break;
default:
ssh_message_reply_default(message);
}
ssh_message_free(message);
} while (!auth);
if(!auth){
printf("auth error: %s\n",ssh_get_error(session));
ssh_disconnect(session);
return 1;
}
do {
message=ssh_message_get(session);
if(message){
switch(ssh_message_type(message)){
case SSH_REQUEST_CHANNEL_OPEN:
if(ssh_message_subtype(message)==SSH_CHANNEL_SESSION){
chan=ssh_message_channel_request_open_reply_accept(message);
break;
}
default:
ssh_message_reply_default(message);
}
ssh_message_free(message);
}
} while(message && !chan);
if(!chan){
printf("error : %s\n",ssh_get_error(session));
ssh_finalize();
return 1;
}
do {
message=ssh_message_get(session);
if(message && ssh_message_type(message)==SSH_REQUEST_CHANNEL &&
ssh_message_subtype(message)==SSH_CHANNEL_REQUEST_SHELL){
// if(!strcmp(ssh_message_channel_request_subsystem(message),"sftp")){
sftp=1;
ssh_message_channel_request_reply_success(message);
break;
// }
}
if(!sftp){
ssh_message_reply_default(message);
}
ssh_message_free(message);
} while (message && !sftp);
if(!sftp){
printf("error : %s\n",ssh_get_error(session));
return 1;
}
printf("it works !\n");
do{
i=ssh_channel_read(chan,buf, 2048, 0);
if(i>0) {
ssh_channel_write(chan, buf, i);
if (write(1,buf,i) < 0) {
printf("error writing to buffer\n");
return 1;
}
}
} while (i>0);
ssh_disconnect(session);
ssh_bind_free(sshbind);
#ifdef WITH_PCAP
cleanup_pcap();
#endif
ssh_finalize();
return 0;
}
static void select_loop(ssh_session_t *session,ssh_channel_t *channel)
{
fd_set fds;
struct timeval timeout;
char buffer[4096];
/* channels will be set to the channels to poll.
* outchannels will contain the result of the poll
*/
ssh_channel_t *channels[2], *outchannels[2];
int lus;
int eof=0;
int maxfd;
unsigned int r;
int ret;
while(channel)
{
do
{
FD_ZERO(&fds);
if(!eof)
{
FD_SET(0, &fds);
}
timeout.tv_sec = 30;
timeout.tv_usec = 0;
FD_SET(ssh_get_fd(session), &fds);
maxfd = ssh_get_fd(session) + 1;
channels[0] = channel; // set the first channel we want to read from
channels[1] = NULL;
ret = ssh_select(channels, outchannels, maxfd, &fds, &timeout);
if(signal_delayed)
{
sizechanged();
}
if(ret == EINTR)
{
continue;
}
if(FD_ISSET(0, &fds))
{
lus = read(0, buffer, sizeof(buffer));
if(lus)
ssh_channel_write(channel, buffer, lus);
else
{
eof = 1;
ssh_channel_send_eof(channel);
}
}
if(channel && ssh_channel_is_closed(channel))
{
ssh_channel_free(channel);
channel=NULL;
channels[0]=NULL;
}
if(outchannels[0])
{
while(channel && ssh_channel_is_open(channel) && (r = ssh_channel_poll(channel,0))!=0)
{
lus = ssh_channel_read(channel,buffer,sizeof(buffer) > r ? r : sizeof(buffer),0);
if(lus == -1)
{
fprintf(stderr, "Error reading channel: %s\n",
ssh_get_error(session));
return;
}
if(lus == 0)
{
ssh_channel_free(channel);
channel=channels[0]=NULL;
}
else
{
if (write(1,buffer,lus) < 0)
{
fprintf(stderr, "Error writing to buffer\n");
return;
}
}
}
while(channel && ssh_channel_is_open(channel) && (r = ssh_channel_poll(channel,1))!=0) /* stderr */
{
lus = ssh_channel_read(channel,buffer,sizeof(buffer) > r ? r : sizeof(buffer),1);
if(lus == -1)
{
fprintf(stderr, "Error reading channel: %s\n",
ssh_get_error(session));
return;
}
if(lus == 0)
{
ssh_channel_free(channel);
channel = channels[0] = NULL;
}
else
{
if (write(2, buffer, lus) < 0)
{
fprintf(stderr, "Error writing to buffer\n");
return;
}
}
}
}
if(channel && ssh_channel_is_closed(channel))
{
ssh_channel_free(channel);
channel=NULL;
}
}
while (ret == EINTR || ret == SSH_EINTR);
}
}
