libssh  0.8.3
The SSH library
libsshpp.hpp
1 /*
2  * This file is part of the SSH Library
3  *
4  * Copyright (c) 2010 by Aris Adamantiadis
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #ifndef LIBSSHPP_HPP_
22 #define LIBSSHPP_HPP_
23 
51 /* do not use deprecated functions */
52 #define LIBSSH_LEGACY_0_4
53 
54 #include <libssh/libssh.h>
55 #include <libssh/server.h>
56 #include <stdlib.h>
57 #include <stdarg.h>
58 #include <stdio.h>
59 #include <string>
60 
61 namespace ssh {
62 
63 class Channel;
68 #ifndef SSH_NO_CPP_EXCEPTIONS
69 
75 public:
76  SshException(ssh_session csession){
77  code=ssh_get_error_code(csession);
78  description=std::string(ssh_get_error(csession));
79  }
80  SshException(const SshException &e){
81  code=e.code;
82  description=e.description;
83  }
89  int getCode(){
90  return code;
91  }
96  std::string getError(){
97  return description;
98  }
99 private:
100  int code;
101  std::string description;
102 };
103 
107 #define ssh_throw(x) if((x)==SSH_ERROR) throw SshException(getCSession())
108 #define ssh_throw_null(CSession,x) if((x)==NULL) throw SshException(CSession)
109 #define void_throwable void
110 #define return_throwable return
111 
112 #else
113 
114 /* No exception at all. All functions will return an error code instead
115  * of an exception
116  */
117 #define ssh_throw(x) if((x)==SSH_ERROR) return SSH_ERROR
118 #define ssh_throw_null(CSession,x) if((x)==NULL) return NULL
119 #define void_throwable int
120 #define return_throwable return SSH_OK
121 #endif
122 
126 class Session {
127  friend class Channel;
128 public:
129  Session(){
130  c_session=ssh_new();
131  }
132  ~Session(){
133  ssh_free(c_session);
134  c_session=NULL;
135  }
142  void_throwable setOption(enum ssh_options_e type, const char *option){
143  ssh_throw(ssh_options_set(c_session,type,option));
144  return_throwable;
145  }
152  void_throwable setOption(enum ssh_options_e type, long int option){
153  ssh_throw(ssh_options_set(c_session,type,&option));
154  return_throwable;
155  }
162  void_throwable setOption(enum ssh_options_e type, void *option){
163  ssh_throw(ssh_options_set(c_session,type,option));
164  return_throwable;
165  }
170  void_throwable connect(){
171  int ret=ssh_connect(c_session);
172  ssh_throw(ret);
173  return_throwable;
174  }
181  int ret=ssh_userauth_publickey_auto(c_session, NULL, NULL);
182  ssh_throw(ret);
183  return ret;
184  }
193  int ret=ssh_userauth_none(c_session,NULL);
194  ssh_throw(ret);
195  return ret;
196  }
197 
214  int userauthKbdint(const char* username, const char* submethods){
215  int ret=ssh_userauth_kbdint(c_session,NULL,NULL);
216  ssh_throw(ret);
217  return ret;
218  }
219 
225  return ssh_userauth_kbdint_getnprompts(c_session);
226  }
227 
244  int userauthKbdintSetAnswer(unsigned int index, const char *answer)
245  {
246  int ret = ssh_userauth_kbdint_setanswer(c_session, index, answer);
247  ssh_throw(ret);
248  return ret;
249  }
250 
251 
252 
259  int userauthPassword(const char *password){
260  int ret=ssh_userauth_password(c_session,NULL,password);
261  ssh_throw(ret);
262  return ret;
263  }
272  int ret=ssh_userauth_try_publickey(c_session, NULL, pubkey);
273  ssh_throw(ret);
274  return ret;
275  }
283  int ret=ssh_userauth_publickey(c_session, NULL, privkey);
284  ssh_throw(ret);
285  return ret;
286  }
287 
293  int getAuthList(){
294  int ret=ssh_userauth_list(c_session, NULL);
295  ssh_throw(ret);
296  return ret;
297  }
301  void disconnect(){
302  ssh_disconnect(c_session);
303  }
308  const char *getDisconnectMessage(){
309  const char *msg=ssh_get_disconnect_message(c_session);
310  return msg;
311  }
315  const char *getError(){
316  return ssh_get_error(c_session);
317  }
321  int getErrorCode(){
322  return ssh_get_error_code(c_session);
323  }
330  socket_t getSocket(){
331  return ssh_get_fd(c_session);
332  }
337  std::string getIssueBanner(){
338  char *banner = ssh_get_issue_banner(c_session);
339  std::string ret = "";
340  if (banner != NULL) {
341  ret = std::string(banner);
342  ::free(banner);
343  }
344  return ret;
345  }
351  return ssh_get_openssh_version(c_session);
352  }
357  int getVersion(){
358  return ssh_get_version(c_session);
359  }
367  int state = ssh_session_is_known_server(c_session);
368  ssh_throw(state);
369  return state;
370  }
371  void log(int priority, const char *format, ...){
372  char buffer[1024];
373  va_list va;
374 
375  va_start(va, format);
376  vsnprintf(buffer, sizeof(buffer), format, va);
377  va_end(va);
378  _ssh_log(priority, "libsshpp", "%s", buffer);
379  }
380 
385  void_throwable optionsCopy(const Session &source){
386  ssh_throw(ssh_options_copy(source.c_session,&c_session));
387  return_throwable;
388  }
394  void_throwable optionsParseConfig(const char *file){
395  ssh_throw(ssh_options_parse_config(c_session,file));
396  return_throwable;
397  }
402  ssh_silent_disconnect(c_session);
403  }
410  int ret = ssh_write_knownhost(c_session);
411  ssh_throw(ret);
412  return ret;
413  }
414 
423  inline Channel *acceptForward(int timeout_ms);
424  /* implemented outside the class due Channel references */
425 
426  void_throwable cancelForward(const char *address, int port){
427  int err=ssh_channel_cancel_forward(c_session, address, port);
428  ssh_throw(err);
429  return_throwable;
430  }
431 
432  void_throwable listenForward(const char *address, int port,
433  int &boundport){
434  int err=ssh_channel_listen_forward(c_session, address, port, &boundport);
435  ssh_throw(err);
436  return_throwable;
437  }
438 
439  ssh_session getCSession(){
440  return c_session;
441  }
442 
443 protected:
444  ssh_session c_session;
445 
446 private:
447  /* No copy constructor, no = operator */
448  Session(const Session &);
449  Session& operator=(const Session &);
450 };
451 
456 class Channel {
457  friend class Session;
458 public:
460  channel = ssh_channel_new(ssh_session.getCSession());
461  this->session = &ssh_session;
462  }
463  ~Channel(){
464  ssh_channel_free(channel);
465  channel=NULL;
466  }
467 
476  Channel *acceptX11(int timeout_ms){
477  ssh_channel x11chan = ssh_channel_accept_x11(channel,timeout_ms);
478  ssh_throw_null(getCSession(),x11chan);
479  Channel *newchan = new Channel(getSession(),x11chan);
480  return newchan;
481  }
488  void_throwable changePtySize(int cols, int rows){
489  int err=ssh_channel_change_pty_size(channel,cols,rows);
490  ssh_throw(err);
491  return_throwable;
492  }
493 
498  void_throwable close(){
499  ssh_throw(ssh_channel_close(channel));
500  return_throwable;
501  }
502 
503  int getExitStatus(){
504  return ssh_channel_get_exit_status(channel);
505  }
506  Session &getSession(){
507  return *session;
508  }
512  bool isClosed(){
513  return ssh_channel_is_closed(channel) != 0;
514  }
518  bool isEof(){
519  return ssh_channel_is_eof(channel) != 0;
520  }
524  bool isOpen(){
525  return ssh_channel_is_open(channel) != 0;
526  }
527  int openForward(const char *remotehost, int remoteport,
528  const char *sourcehost=NULL, int localport=0){
529  int err=ssh_channel_open_forward(channel,remotehost,remoteport,
530  sourcehost, localport);
531  ssh_throw(err);
532  return err;
533  }
534  /* TODO: completely remove this ? */
535  void_throwable openSession(){
536  int err=ssh_channel_open_session(channel);
537  ssh_throw(err);
538  return_throwable;
539  }
540  int poll(bool is_stderr=false){
541  int err=ssh_channel_poll(channel,is_stderr);
542  ssh_throw(err);
543  return err;
544  }
545  int read(void *dest, size_t count){
546  int err;
547  /* handle int overflow */
548  if(count > 0x7fffffff)
549  count = 0x7fffffff;
550  err=ssh_channel_read_timeout(channel,dest,count,false,-1);
551  ssh_throw(err);
552  return err;
553  }
554  int read(void *dest, size_t count, int timeout){
555  int err;
556  /* handle int overflow */
557  if(count > 0x7fffffff)
558  count = 0x7fffffff;
559  err=ssh_channel_read_timeout(channel,dest,count,false,timeout);
560  ssh_throw(err);
561  return err;
562  }
563  int read(void *dest, size_t count, bool is_stderr=false, int timeout=-1){
564  int err;
565  /* handle int overflow */
566  if(count > 0x7fffffff)
567  count = 0x7fffffff;
568  err=ssh_channel_read_timeout(channel,dest,count,is_stderr,timeout);
569  ssh_throw(err);
570  return err;
571  }
572  int readNonblocking(void *dest, size_t count, bool is_stderr=false){
573  int err;
574  /* handle int overflow */
575  if(count > 0x7fffffff)
576  count = 0x7fffffff;
577  err=ssh_channel_read_nonblocking(channel,dest,count,is_stderr);
578  ssh_throw(err);
579  return err;
580  }
581  void_throwable requestEnv(const char *name, const char *value){
582  int err=ssh_channel_request_env(channel,name,value);
583  ssh_throw(err);
584  return_throwable;
585  }
586 
587  void_throwable requestExec(const char *cmd){
588  int err=ssh_channel_request_exec(channel,cmd);
589  ssh_throw(err);
590  return_throwable;
591  }
592  void_throwable requestPty(const char *term=NULL, int cols=0, int rows=0){
593  int err;
594  if(term != NULL && cols != 0 && rows != 0)
595  err=ssh_channel_request_pty_size(channel,term,cols,rows);
596  else
597  err=ssh_channel_request_pty(channel);
598  ssh_throw(err);
599  return_throwable;
600  }
601 
602  void_throwable requestShell(){
603  int err=ssh_channel_request_shell(channel);
604  ssh_throw(err);
605  return_throwable;
606  }
607  void_throwable requestSendSignal(const char *signum){
608  int err=ssh_channel_request_send_signal(channel, signum);
609  ssh_throw(err);
610  return_throwable;
611  }
612  void_throwable requestSubsystem(const char *subsystem){
613  int err=ssh_channel_request_subsystem(channel,subsystem);
614  ssh_throw(err);
615  return_throwable;
616  }
617  int requestX11(bool single_connection,
618  const char *protocol, const char *cookie, int screen_number){
619  int err=ssh_channel_request_x11(channel,single_connection,
620  protocol, cookie, screen_number);
621  ssh_throw(err);
622  return err;
623  }
624  void_throwable sendEof(){
625  int err=ssh_channel_send_eof(channel);
626  ssh_throw(err);
627  return_throwable;
628  }
638  int write(const void *data, size_t len, bool is_stderr=false){
639  int ret;
640  if(is_stderr){
641  ret=ssh_channel_write_stderr(channel,data,len);
642  } else {
643  ret=ssh_channel_write(channel,data,len);
644  }
645  ssh_throw(ret);
646  return ret;
647  }
648 
649  ssh_session getCSession(){
650  return session->getCSession();
651  }
652 
653  ssh_channel getCChannel() {
654  return channel;
655  }
656 
657 protected:
658  Session *session;
659  ssh_channel channel;
660 
661 private:
662  Channel (Session &ssh_session, ssh_channel c_channel){
663  this->channel=c_channel;
664  this->session = &ssh_session;
665  }
666  /* No copy and no = operator */
667  Channel(const Channel &);
668  Channel &operator=(const Channel &);
669 };
670 
671 
672 inline Channel *Session::acceptForward(int timeout_ms){
673  ssh_channel forward =
674  ssh_channel_accept_forward(c_session, timeout_ms, NULL);
675  ssh_throw_null(c_session,forward);
676  Channel *newchan = new Channel(*this,forward);
677  return newchan;
678  }
679 
680 } // namespace ssh
681 
683 #endif /* LIBSSHPP_HPP_ */
int userauthNone()
Authenticates using the "none" method. Prefer using autopubkey if possible.
Definition: libsshpp.hpp:192
int userauthKbdintGetNPrompts()
Get the number of prompts (questions) the server has given.
Definition: libsshpp.hpp:224
int getAuthList()
Returns the available authentication methods from the server.
Definition: libsshpp.hpp:293
Definition: libsshpp.hpp:61
void_throwable setOption(enum ssh_options_e type, void *option)
sets an SSH session options
Definition: libsshpp.hpp:162
Definition: pki.h:42
LIBSSH_API int ssh_userauth_kbdint(ssh_session session, const char *user, const char *submethods)
Try to authenticate through the "keyboard-interactive" method.
Definition: auth.c:1637
LIBSSH_API int ssh_options_parse_config(ssh_session session, const char *filename)
Parse the ssh config file.
Definition: options.c:1286
Channel * acceptX11(int timeout_ms)
accept an incoming X11 connection
Definition: libsshpp.hpp:476
LIBSSH_API int ssh_channel_request_x11(ssh_channel channel, int single_connection, const char *protocol, const char *cookie, int screen_number)
Sends the "x11-req" channel request over an existing session channel.
Definition: channels.c:1850
LIBSSH_API int ssh_channel_request_shell(ssh_channel channel)
Request a shell.
Definition: channels.c:1739
LIBSSH_API int ssh_channel_open_forward(ssh_channel channel, const char *remotehost, int remoteport, const char *sourcehost, int localport)
Open a TCP/IP forwarding channel.
Definition: channels.c:925
LIBSSH_API int ssh_channel_is_eof(ssh_channel channel)
Check if remote has sent an EOF.
Definition: channels.c:1416
LIBSSH_API int ssh_channel_read_timeout(ssh_channel channel, void *dest, uint32_t count, int is_stderr, int timeout_ms)
Reads data from a channel.
Definition: channels.c:2668
int isServerKnown()
verifies that the server is known
Definition: libsshpp.hpp:366
LIBSSH_API int ssh_channel_send_eof(ssh_channel channel)
Send an end of file on the channel.
Definition: channels.c:1058
Definition: channels.h:57
LIBSSH_API int ssh_channel_close(ssh_channel channel)
Close a channel.
Definition: channels.c:1110
int userauthPublickey(ssh_key privkey)
Authenticates using the publickey method.
Definition: libsshpp.hpp:282
void_throwable optionsCopy(const Session &source)
copies options from a session to another
Definition: libsshpp.hpp:385
int getVersion()
returns the version of the SSH protocol being used
Definition: libsshpp.hpp:357
void_throwable changePtySize(int cols, int rows)
change the size of a pseudoterminal
Definition: libsshpp.hpp:488
Definition: libsshpp.hpp:126
LIBSSH_API int ssh_get_openssh_version(ssh_session session)
Get the version of the OpenSSH server, if it is not an OpenSSH server then 0 will be returned...
Definition: client.c:631
LIBSSH_API int ssh_userauth_list(ssh_session session, const char *username)
Get available authentication methods from the server.
Definition: auth.c:355
LIBSSH_API const char * ssh_get_error(void *error)
Retrieve the error text message from the last error.
Definition: error.c:128
LIBSSH_API int ssh_channel_write(ssh_channel channel, const void *data, uint32_t len)
Blocking write on a channel.
Definition: channels.c:1373
Definition: session.h:102
void_throwable optionsParseConfig(const char *file)
parses a configuration file for options
Definition: libsshpp.hpp:394
LIBSSH_API int ssh_channel_request_pty_size(ssh_channel channel, const char *term, int cols, int rows)
Request a pty with a specific type and size.
Definition: channels.c:1618
LIBSSH_API int ssh_channel_request_subsystem(ssh_channel channel, const char *subsystem)
Request a subsystem (for example "sftp").
Definition: channels.c:1761
the ssh::Channel class describes the state of an SSH channel.
Definition: libsshpp.hpp:456
LIBSSH_API int ssh_get_version(ssh_session session)
Get the protocol version of the session.
Definition: session.c:801
LIBSSH_API int ssh_channel_request_env(ssh_channel channel, const char *name, const char *value)
Set environment variables.
Definition: channels.c:2303
int userauthKbdint(const char *username, const char *submethods)
Authenticate through the "keyboard-interactive" method.
Definition: libsshpp.hpp:214
int userauthPublickeyAuto(void)
Authenticates automatically using public key.
Definition: libsshpp.hpp:180
LIBSSH_API char * ssh_get_issue_banner(ssh_session session)
Get the issue banner from the server.
Definition: client.c:605
int write(const void *data, size_t len, bool is_stderr=false)
Writes on a channel.
Definition: libsshpp.hpp:638
LIBSSH_API int ssh_userauth_kbdint_getnprompts(ssh_session session)
Get the number of prompts (questions) the server has given.
Definition: auth.c:1680
std::string getIssueBanner()
gets the Issue banner from the ssh server
Definition: libsshpp.hpp:337
LIBSSH_API int ssh_options_copy(ssh_session src, ssh_session *dest)
Duplicate the options of a session structure.
Definition: options.c:64
void disconnect()
Disconnects from the SSH server and closes connection.
Definition: libsshpp.hpp:301
int getCode()
returns the Error code
Definition: libsshpp.hpp:89
LIBSSH_API int ssh_channel_open_session(ssh_channel channel)
Open a session channel (suited for a shell, not TCP forwarding).
Definition: channels.c:860
if defined, disable C++ exceptions for libssh c++ wrapper
Definition: libsshpp.hpp:74
LIBSSH_API int ssh_channel_is_open(ssh_channel channel)
Check if the channel is open or not.
Definition: channels.c:1386
LIBSSH_API int ssh_write_knownhost(ssh_session session)
This function is deprecated.
Definition: known_hosts.c:519
LIBSSH_API int ssh_channel_is_closed(ssh_channel channel)
Check if the channel is closed or not.
Definition: channels.c:1402
socket_t getSocket()
returns the file descriptor used for the communication
Definition: libsshpp.hpp:330
int userauthKbdintSetAnswer(unsigned int index, const char *answer)
Set the answer for a question from a message block.
Definition: libsshpp.hpp:244
LIBSSH_API int ssh_channel_poll(ssh_channel channel, int is_stderr)
Polls a channel for data to read.
Definition: channels.c:2835
int writeKnownhost()
Writes the known host file with current host key.
Definition: libsshpp.hpp:409
ssh_channel ssh_channel_new(ssh_session session)
Allocate a new channel.
Definition: channels.c:79
LIBSSH_API int ssh_options_set(ssh_session session, enum ssh_options_e type, const void *value)
This function can set all possible ssh options.
Definition: options.c:430
LIBSSH_API int ssh_userauth_password(ssh_session session, const char *username, const char *password)
Try to authenticate by password.
Definition: auth.c:1222
LIBSSH_API int ssh_userauth_publickey_auto(ssh_session session, const char *username, const char *passphrase)
Tries to automatically authenticate with public key and "none".
Definition: auth.c:1002
LIBSSH_API int ssh_userauth_kbdint_setanswer(ssh_session session, unsigned int i, const char *answer)
Set the answer for a question from a message block.
Definition: auth.c:1835
LIBSSH_API int ssh_userauth_publickey(ssh_session session, const char *username, const ssh_key privkey)
Authenticate with public/private key or certificate.
Definition: auth.c:601
LIBSSH_API socket_t ssh_get_fd(ssh_session session)
Get the fd of a connection.
Definition: session.c:534
int userauthPassword(const char *password)
Authenticates using the password method.
Definition: libsshpp.hpp:259
bool isEof()
returns true if channel is in EOF state
Definition: libsshpp.hpp:518
LIBSSH_API int ssh_channel_change_pty_size(ssh_channel channel, int cols, int rows)
Change the size of the terminal associated to a channel.
Definition: channels.c:1700
LIBSSH_API int ssh_connect(ssh_session session)
Connect to the ssh server.
Definition: client.c:490
LIBSSH_API void ssh_disconnect(ssh_session session)
Disconnect from a session (client or server). The session can then be reused to open a new session...
Definition: client.c:645
int getOpensshVersion()
returns the OpenSSH version (server) if possible
Definition: libsshpp.hpp:350
bool isClosed()
returns true if channel is in closed state
Definition: libsshpp.hpp:512
LIBSSH_API int ssh_userauth_none(ssh_session session, const char *username)
Try to authenticate through the "none" method.
Definition: auth.c:385
void_throwable setOption(enum ssh_options_e type, const char *option)
sets an SSH session options
Definition: libsshpp.hpp:142
LIBSSH_API ssh_channel ssh_channel_accept_x11(ssh_channel channel, int timeout_ms)
Accept an X11 forwarding channel.
Definition: channels.c:1966
LIBSSH_API int ssh_channel_listen_forward(ssh_session session, const char *address, int port, int *bound_port)
Sends the "tcpip-forward" global request to ask the server to begin listening for inbound connections...
Definition: channels.c:2170
LIBSSH_API int ssh_channel_request_send_signal(ssh_channel channel, const char *signum)
Send a signal to remote process (as described in RFC 4254, section 6.9).
Definition: channels.c:2443
std::string getError()
returns the error message of the last exception
Definition: libsshpp.hpp:96
void_throwable connect()
connects to the remote host
Definition: libsshpp.hpp:170
LIBSSH_API ssh_channel ssh_channel_accept_forward(ssh_session session, int timeout_ms, int *destination_port)
Accept an incoming TCP/IP forwarding channel and get information about incomming connection.
Definition: channels.c:2233
int userauthTryPublickey(ssh_key pubkey)
Try to authenticate using the publickey method.
Definition: libsshpp.hpp:271
void silentDisconnect()
silently disconnect from remote host
Definition: libsshpp.hpp:401
Channel * acceptForward(int timeout_ms)
accept an incoming forward connection
Definition: libsshpp.hpp:672
LIBSSH_API int ssh_channel_request_exec(ssh_channel channel, const char *cmd)
Run a shell command without an interactive shell.
Definition: channels.c:2373
bool isOpen()
returns true if channel is in open state
Definition: libsshpp.hpp:524
LIBSSH_API int ssh_channel_request_pty(ssh_channel channel)
Request a PTY.
Definition: channels.c:1681
LIBSSH_API enum ssh_known_hosts_e ssh_session_is_known_server(ssh_session session)
Check if the servers public key for the connected session is known.
Definition: knownhosts.c:889
LIBSSH_API void ssh_silent_disconnect(ssh_session session)
Disconnect impolitely from a remote host by closing the socket.
Definition: session.c:435
LIBSSH_API const char * ssh_get_disconnect_message(ssh_session session)
Get the disconnect message from the server.
Definition: session.c:776
LIBSSH_API ssh_session ssh_new(void)
Create a new ssh session.
Definition: session.c:58
LIBSSH_API void ssh_channel_free(ssh_channel channel)
Close and free a channel.
Definition: channels.c:981
LIBSSH_API int ssh_userauth_try_publickey(ssh_session session, const char *username, const ssh_key pubkey)
Try to authenticate with the given public key.
Definition: auth.c:468
void_throwable setOption(enum ssh_options_e type, long int option)
sets an SSH session options
Definition: libsshpp.hpp:152
LIBSSH_API int ssh_channel_get_exit_status(ssh_channel channel)
Get the exit status of the channel (error code from the executed instruction).
Definition: channels.c:2964
LIBSSH_API int ssh_channel_cancel_forward(ssh_session session, const char *address, int port)
Sends the "cancel-tcpip-forward" global request to ask the server to cancel the tcpip-forward request...
Definition: channels.c:2252
void_throwable close()
closes a channel
Definition: libsshpp.hpp:498
LIBSSH_API int ssh_channel_write_stderr(ssh_channel channel, const void *data, uint32_t len)
Blocking write on a channel stderr.
Definition: channels.c:3221
const char * getDisconnectMessage()
Returns the disconnect message from the server, if any.
Definition: libsshpp.hpp:308
LIBSSH_API void ssh_free(ssh_session session)
Deallocate a SSH session handle.
Definition: session.c:169
LIBSSH_API int ssh_channel_read_nonblocking(ssh_channel channel, void *dest, uint32_t count, int is_stderr)
Do a nonblocking read on the channel.
Definition: channels.c:2783
LIBSSH_API int ssh_get_error_code(void *error)
Retrieve the error code from the last error.
Definition: error.c:148