自学教程：C++ ssh_channel_read函数代码示例

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_tread_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 intptob_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;}

//.........这里部分代码省略.........					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;}

//.........这里部分代码省略.........        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 = "gzleo";    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;

//.........这里部分代码省略.........      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;//.........这里部分代码省略.........