Loading...
Searching...
No Matches
libsshpp.hpp
/*
* This file is part of the SSH Library
*
* Copyright (c) 2010 by Aris Adamantiadis
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef LIBSSHPP_HPP_
#define LIBSSHPP_HPP_
/* do not use deprecated functions */
#define LIBSSH_LEGACY_0_4
#include <libssh/libssh.h>
#include <libssh/server.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string>
namespace ssh {
class Channel;
#ifndef SSH_NO_CPP_EXCEPTIONS
class SshException{
public:
SshException(ssh_session csession){
code=ssh_get_error_code(csession);
description=std::string(ssh_get_error(csession));
}
SshException(const SshException &e){
code=e.code;
description=e.description;
}
int getCode(){
return code;
}
std::string getError(){
return description;
}
private:
int code;
std::string description;
};
#define ssh_throw(x) if((x)==SSH_ERROR) throw SshException(getCSession())
#define ssh_throw_null(CSession,x) if((x)==NULL) throw SshException(CSession)
#define void_throwable void
#define return_throwable return
#else
/* No exception at all. All functions will return an error code instead
* of an exception
*/
#define ssh_throw(x) if((x)==SSH_ERROR) return SSH_ERROR
#define ssh_throw_null(CSession,x) if((x)==NULL) return NULL
#define void_throwable int
#define return_throwable return SSH_OK
#endif
class Session {
friend class Channel;
public:
Session(){
c_session=ssh_new();
}
~Session(){
ssh_free(c_session);
c_session=NULL;
}
void_throwable setOption(enum ssh_options_e type, const char *option){
ssh_throw(ssh_options_set(c_session,type,option));
return_throwable;
}
void_throwable setOption(enum ssh_options_e type, long int option){
ssh_throw(ssh_options_set(c_session,type,&option));
return_throwable;
}
void_throwable setOption(enum ssh_options_e type, void *option){
ssh_throw(ssh_options_set(c_session,type,option));
return_throwable;
}
void_throwable connect(){
int ret=ssh_connect(c_session);
ssh_throw(ret);
return_throwable;
}
int userauthPublickeyAuto(void){
int ret=ssh_userauth_publickey_auto(c_session, NULL, NULL);
ssh_throw(ret);
return ret;
}
int userauthNone(){
int ret=ssh_userauth_none(c_session,NULL);
ssh_throw(ret);
return ret;
}
int userauthKbdint(const char* username, const char* submethods){
int ret = ssh_userauth_kbdint(c_session, username, submethods);
ssh_throw(ret);
return ret;
}
int userauthKbdintGetNPrompts(){
return ssh_userauth_kbdint_getnprompts(c_session);
}
int userauthKbdintSetAnswer(unsigned int index, const char *answer)
{
int ret = ssh_userauth_kbdint_setanswer(c_session, index, answer);
ssh_throw(ret);
return ret;
}
int userauthPassword(const char *password){
int ret=ssh_userauth_password(c_session,NULL,password);
ssh_throw(ret);
return ret;
}
int userauthTryPublickey(ssh_key pubkey){
int ret=ssh_userauth_try_publickey(c_session, NULL, pubkey);
ssh_throw(ret);
return ret;
}
int userauthPublickey(ssh_key privkey){
int ret=ssh_userauth_publickey(c_session, NULL, privkey);
ssh_throw(ret);
return ret;
}
int getAuthList(){
int ret=ssh_userauth_list(c_session, NULL);
ssh_throw(ret);
return ret;
}
void disconnect(){
ssh_disconnect(c_session);
}
const char *getDisconnectMessage(){
const char *msg=ssh_get_disconnect_message(c_session);
return msg;
}
const char *getError(){
return ssh_get_error(c_session);
}
int getErrorCode(){
return ssh_get_error_code(c_session);
}
socket_t getSocket(){
return ssh_get_fd(c_session);
}
std::string getIssueBanner(){
char *banner = ssh_get_issue_banner(c_session);
std::string ret = "";
if (banner != NULL) {
ret = std::string(banner);
::free(banner);
}
return ret;
}
int getOpensshVersion(){
return ssh_get_openssh_version(c_session);
}
int getVersion(){
return ssh_get_version(c_session);
}
int isServerKnown(){
int state = ssh_session_is_known_server(c_session);
ssh_throw(state);
return state;
}
void log(int priority, const char *format, ...){
va_list va;
va_start(va, format);
ssh_vlog(priority, "libsshpp", format, &va);
va_end(va);
}
void_throwable optionsCopy(const Session &source){
ssh_throw(ssh_options_copy(source.c_session,&c_session));
return_throwable;
}
void_throwable optionsParseConfig(const char *file){
ssh_throw(ssh_options_parse_config(c_session,file));
return_throwable;
}
void silentDisconnect(){
ssh_silent_disconnect(c_session);
}
int writeKnownhost(){
int ret = ssh_session_update_known_hosts(c_session);
ssh_throw(ret);
return ret;
}
inline Channel *acceptForward(int timeout_ms);
/* implemented outside the class due Channel references */
void_throwable cancelForward(const char *address, int port){
int err=ssh_channel_cancel_forward(c_session, address, port);
ssh_throw(err);
return_throwable;
}
void_throwable listenForward(const char *address, int port,
int &boundport){
int err=ssh_channel_listen_forward(c_session, address, port, &boundport);
ssh_throw(err);
return_throwable;
}
ssh_session getCSession(){
return c_session;
}
protected:
ssh_session c_session;
private:
/* No copy constructor, no = operator */
Session(const Session &);
Session& operator=(const Session &);
};
class Channel {
friend class Session;
public:
Channel(Session &ssh_session){
channel = ssh_channel_new(ssh_session.getCSession());
this->session = &ssh_session;
}
~Channel(){
ssh_channel_free(channel);
channel=NULL;
}
Channel *acceptX11(int timeout_ms){
ssh_channel x11chan = ssh_channel_accept_x11(channel,timeout_ms);
ssh_throw_null(getCSession(),x11chan);
Channel *newchan = new Channel(getSession(),x11chan);
return newchan;
}
void_throwable changePtySize(int cols, int rows){
int err=ssh_channel_change_pty_size(channel,cols,rows);
ssh_throw(err);
return_throwable;
}
void_throwable close(){
ssh_throw(ssh_channel_close(channel));
return_throwable;
}
/*
* @deprecated Please use getExitState()
*/
int getExitStatus() {
uint32_t exit_status = (uint32_t)-1;
ssh_channel_get_exit_state(channel, &exit_status, NULL, NULL);
return exit_status;
}
void_throwable getExitState(uint32_t & pexit_code,
char **pexit_signal,
int & pcore_dumped) {
ssh_throw(ssh_channel_get_exit_state(channel,
&pexit_code,
pexit_signal,
&pcore_dumped));
return_throwable;
}
Session &getSession(){
return *session;
}
bool isClosed(){
return ssh_channel_is_closed(channel) != 0;
}
bool isEof(){
return ssh_channel_is_eof(channel) != 0;
}
bool isOpen(){
return ssh_channel_is_open(channel) != 0;
}
int openForward(const char *remotehost, int remoteport,
const char *sourcehost, int localport=0){
int err=ssh_channel_open_forward(channel,remotehost,remoteport,
sourcehost, localport);
ssh_throw(err);
return err;
}
/* TODO: completely remove this ? */
void_throwable openSession(){
int err=ssh_channel_open_session(channel);
ssh_throw(err);
return_throwable;
}
int poll(bool is_stderr=false){
int err=ssh_channel_poll(channel,is_stderr);
ssh_throw(err);
return err;
}
int read(void *dest, size_t count){
int err;
/* handle int overflow */
if(count > 0x7fffffff)
count = 0x7fffffff;
err=ssh_channel_read_timeout(channel,dest,count,false,-1);
ssh_throw(err);
return err;
}
int read(void *dest, size_t count, int timeout){
int err;
/* handle int overflow */
if(count > 0x7fffffff)
count = 0x7fffffff;
err=ssh_channel_read_timeout(channel,dest,count,false,timeout);
ssh_throw(err);
return err;
}
int read(void *dest, size_t count, bool is_stderr=false, int timeout=-1){
int err;
/* handle int overflow */
if(count > 0x7fffffff)
count = 0x7fffffff;
err=ssh_channel_read_timeout(channel,dest,count,is_stderr,timeout);
ssh_throw(err);
return err;
}
int readNonblocking(void *dest, size_t count, bool is_stderr=false){
int err;
/* handle int overflow */
if(count > 0x7fffffff)
count = 0x7fffffff;
err=ssh_channel_read_nonblocking(channel,dest,count,is_stderr);
ssh_throw(err);
return err;
}
void_throwable requestEnv(const char *name, const char *value){
int err=ssh_channel_request_env(channel,name,value);
ssh_throw(err);
return_throwable;
}
void_throwable requestExec(const char *cmd){
int err=ssh_channel_request_exec(channel,cmd);
ssh_throw(err);
return_throwable;
}
void_throwable requestPty(const char *term=NULL, int cols=0, int rows=0,
const unsigned char* modes=NULL, size_t modes_len=0){
int err;
if(term != NULL && cols != 0 && rows != 0 && modes != NULL)
err=ssh_channel_request_pty_size_modes(channel,term,cols,rows,modes,modes_len);
else if(term != NULL && cols != 0 && rows != 0)
err=ssh_channel_request_pty_size(channel,term,cols,rows);
else
err=ssh_channel_request_pty(channel);
ssh_throw(err);
return_throwable;
}
void_throwable requestShell(){
int err=ssh_channel_request_shell(channel);
ssh_throw(err);
return_throwable;
}
void_throwable requestSendSignal(const char *signum){
int err=ssh_channel_request_send_signal(channel, signum);
ssh_throw(err);
return_throwable;
}
void_throwable requestSubsystem(const char *subsystem){
int err=ssh_channel_request_subsystem(channel,subsystem);
ssh_throw(err);
return_throwable;
}
int requestX11(bool single_connection,
const char *protocol, const char *cookie, int screen_number){
int err=ssh_channel_request_x11(channel,single_connection,
protocol, cookie, screen_number);
ssh_throw(err);
return err;
}
void_throwable sendEof(){
int err=ssh_channel_send_eof(channel);
ssh_throw(err);
return_throwable;
}
int write(const void *data, size_t len, bool is_stderr=false){
int ret;
if(is_stderr){
ret=ssh_channel_write_stderr(channel,data,len);
} else {
ret=ssh_channel_write(channel,data,len);
}
ssh_throw(ret);
return ret;
}
ssh_session getCSession(){
return session->getCSession();
}
ssh_channel getCChannel() {
return channel;
}
protected:
Session *session;
ssh_channel channel;
private:
Channel (Session &ssh_session, ssh_channel c_channel){
this->channel=c_channel;
this->session = &ssh_session;
}
/* No copy and no = operator */
Channel(const Channel &);
Channel &operator=(const Channel &);
};
inline Channel *Session::acceptForward(int timeout_ms){
ssh_channel forward =
ssh_channel_open_forward_port(c_session, timeout_ms, NULL, NULL, NULL);
ssh_throw_null(c_session,forward);
Channel *newchan = new Channel(*this,forward);
return newchan;
}
} // namespace ssh
#endif /* LIBSSHPP_HPP_ */
ssh::Channel
the ssh::Channel class describes the state of an SSH channel.
Definition libsshpp.hpp:454
ssh::Channel::write
int write(const void *data, size_t len, bool is_stderr=false)
Writes on a channel.
Definition libsshpp.hpp:653
ssh::Channel::close
void_throwable close()
closes a channel
Definition libsshpp.hpp:496
ssh::Channel::isClosed
bool isClosed()
returns true if channel is in closed state
Definition libsshpp.hpp:524
ssh::Channel::changePtySize
void_throwable changePtySize(int cols, int rows)
change the size of a pseudoterminal
Definition libsshpp.hpp:486
ssh::Channel::isEof
bool isEof()
returns true if channel is in EOF state
Definition libsshpp.hpp:530
ssh::Channel::isOpen
bool isOpen()
returns true if channel is in open state
Definition libsshpp.hpp:536
ssh::Channel::acceptX11
Channel * acceptX11(int timeout_ms)
accept an incoming X11 connection
Definition libsshpp.hpp:474
ssh::Session::getAuthList
int getAuthList()
Returns the available authentication methods from the server.
Definition libsshpp.hpp:293
ssh::Session::isServerKnown
int isServerKnown()
verifies that the server is known
Definition libsshpp.hpp:366
ssh::Session::userauthKbdintGetNPrompts
int userauthKbdintGetNPrompts()
Get the number of prompts (questions) the server has given.
Definition libsshpp.hpp:224
ssh::Session::userauthKbdint
int userauthKbdint(const char *username, const char *submethods)
Authenticate through the "keyboard-interactive" method.
Definition libsshpp.hpp:214
ssh::Session::silentDisconnect
void silentDisconnect()
silently disconnect from remote host
Definition libsshpp.hpp:399
ssh::Session::setOption
void_throwable setOption(enum ssh_options_e type, long int option)
sets an SSH session options
Definition libsshpp.hpp:152
ssh::Session::getSocket
socket_t getSocket()
returns the file descriptor used for the communication
Definition libsshpp.hpp:330
ssh::Session::setOption
void_throwable setOption(enum ssh_options_e type, void *option)
sets an SSH session options
Definition libsshpp.hpp:162
ssh::Session::setOption
void_throwable setOption(enum ssh_options_e type, const char *option)
sets an SSH session options
Definition libsshpp.hpp:142
ssh::Session::getVersion
int getVersion()
returns the version of the SSH protocol being used
Definition libsshpp.hpp:357
ssh::Session::getDisconnectMessage
const char * getDisconnectMessage()
Returns the disconnect message from the server, if any.
Definition libsshpp.hpp:308
ssh::Session::userauthPublickeyAuto
int userauthPublickeyAuto(void)
Authenticates automatically using public key.
Definition libsshpp.hpp:180
ssh::Session::acceptForward
Channel * acceptForward(int timeout_ms)
accept an incoming forward connection
Definition libsshpp.hpp:687
ssh::Session::connect
void_throwable connect()
connects to the remote host
Definition libsshpp.hpp:170
ssh::Session::userauthPublickey
int userauthPublickey(ssh_key privkey)
Authenticates using the publickey method.
Definition libsshpp.hpp:282
ssh::Session::userauthKbdintSetAnswer
int userauthKbdintSetAnswer(unsigned int index, const char *answer)
Set the answer for a question from a message block.
Definition libsshpp.hpp:244
ssh::Session::userauthNone
int userauthNone()
Authenticates using the "none" method. Prefer using autopubkey if possible.
Definition libsshpp.hpp:192
ssh::Session::getIssueBanner
std::string getIssueBanner()
gets the Issue banner from the ssh server
Definition libsshpp.hpp:337
ssh::Session::getOpensshVersion
int getOpensshVersion()
returns the OpenSSH version (server) if possible
Definition libsshpp.hpp:350
ssh::Session::disconnect
void disconnect()
Disconnects from the SSH server and closes connection.
Definition libsshpp.hpp:301
ssh::Session::userauthPassword
int userauthPassword(const char *password)
Authenticates using the password method.
Definition libsshpp.hpp:259
ssh::Session::optionsCopy
void_throwable optionsCopy(const Session &source)
copies options from a session to another
Definition libsshpp.hpp:383
ssh::Session::writeKnownhost
int writeKnownhost()
Writes the known host file with current host key.
Definition libsshpp.hpp:407
ssh::Session::optionsParseConfig
void_throwable optionsParseConfig(const char *file)
parses a configuration file for options
Definition libsshpp.hpp:392
ssh::Session::userauthTryPublickey
int userauthTryPublickey(ssh_key pubkey)
Try to authenticate using the publickey method.
Definition libsshpp.hpp:271
ssh::SshException::getCode
int getCode()
returns the Error code
Definition libsshpp.hpp:89
ssh::SshException::getError
std::string getError()
returns the error message of the last exception
Definition libsshpp.hpp:96
ssh_userauth_list
LIBSSH_API int ssh_userauth_list(ssh_session session, const char *username)
Get available authentication methods from the server.
Definition auth.c:380
ssh_userauth_password
LIBSSH_API int ssh_userauth_password(ssh_session session, const char *username, const char *password)
Try to authenticate by password.
Definition auth.c:1629
ssh_userauth_publickey_auto
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:1285
ssh_userauth_none
LIBSSH_API int ssh_userauth_none(ssh_session session, const char *username)
Try to authenticate through the "none" method.
Definition auth.c:410
ssh_userauth_try_publickey
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:494
ssh_userauth_kbdint
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:2059
ssh_userauth_kbdint_setanswer
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:2266
ssh_userauth_publickey
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:628
ssh_userauth_kbdint_getnprompts
LIBSSH_API int ssh_userauth_kbdint_getnprompts(ssh_session session)
Get the number of prompts (questions) the server has given.
Definition auth.c:2103
ssh_channel_request_subsystem
LIBSSH_API int ssh_channel_request_subsystem(ssh_channel channel, const char *subsystem)
Request a subsystem (for example "sftp").
Definition channels.c:2128
ssh_channel_send_eof
LIBSSH_API int ssh_channel_send_eof(ssh_channel channel)
Send an end of file on the channel.
Definition channels.c:1366
ssh_channel_poll
LIBSSH_API int ssh_channel_poll(ssh_channel channel, int is_stderr)
Polls a channel for data to read.
Definition channels.c:3260
ssh_channel_get_exit_state
LIBSSH_API int ssh_channel_get_exit_state(ssh_channel channel, uint32_t *pexit_code, char **pexit_signal, int *pcore_dumped)
Get the exit state of the channel (error code from the executed instruction or signal).
Definition channels.c:3424
ssh_channel_close
LIBSSH_API int ssh_channel_close(ssh_channel channel)
Close a channel.
Definition channels.c:1427
ssh_channel_request_pty_size_modes
LIBSSH_API int ssh_channel_request_pty_size_modes(ssh_channel channel, const char *term, int cols, int rows, const unsigned char *modes, size_t modes_len)
Request a pty with a specific type and size.
Definition channels.c:1963
ssh_channel_read_timeout
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:3088
ssh_channel_request_pty
LIBSSH_API int ssh_channel_request_pty(ssh_channel channel)
Request a PTY.
Definition channels.c:2045
ssh_channel_cancel_forward
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:2674
ssh_channel_open_forward_port
LIBSSH_API ssh_channel ssh_channel_open_forward_port(ssh_session session, int timeout_ms, int *destination_port, char **originator, int *originator_port)
Accept an incoming TCP/IP forwarding channel and get information about incoming connection.
Definition channels.c:2655
ssh_channel_accept_x11
LIBSSH_API ssh_channel ssh_channel_accept_x11(ssh_channel channel, int timeout_ms)
Accept an X11 forwarding channel.
Definition channels.c:2356
ssh_channel_request_exec
LIBSSH_API int ssh_channel_request_exec(ssh_channel channel, const char *cmd)
Run a shell command without an interactive shell.
Definition channels.c:2797
ssh_channel_write
LIBSSH_API int ssh_channel_write(ssh_channel channel, const void *data, uint32_t len)
Blocking write on a channel.
Definition channels.c:1698
ssh_channel_listen_forward
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:2565
ssh_channel_request_env
LIBSSH_API int ssh_channel_request_env(ssh_channel channel, const char *name, const char *value)
Set environment variables.
Definition channels.c:2726
ssh_channel_write_stderr
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:3759
ssh_channel_request_send_signal
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:2863
ssh_channel_is_open
LIBSSH_API int ssh_channel_is_open(ssh_channel channel)
Check if the channel is open or not.
Definition channels.c:1712
ssh_channel_read_nonblocking
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:3199
ssh_channel_is_closed
LIBSSH_API int ssh_channel_is_closed(ssh_channel channel)
Check if the channel is closed or not.
Definition channels.c:1729
ssh_channel_is_eof
LIBSSH_API int ssh_channel_is_eof(ssh_channel channel)
Check if remote has sent an EOF.
Definition channels.c:1744
ssh_channel_free
LIBSSH_API void ssh_channel_free(ssh_channel channel)
Close and free a channel.
Definition channels.c:1259
ssh_channel_new
LIBSSH_API ssh_channel ssh_channel_new(ssh_session session)
Allocate a new channel.
Definition channels.c:90
ssh_channel_request_x11
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:2232
ssh_channel_open_forward
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:1120
ssh_channel_request_shell
LIBSSH_API int ssh_channel_request_shell(ssh_channel channel)
Request a shell.
Definition channels.c:2105
ssh_channel_open_session
LIBSSH_API int ssh_channel_open_session(ssh_channel channel)
Open a session channel (suited for a shell, not TCP forwarding).
Definition channels.c:1053
ssh_channel_change_pty_size
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:2065
ssh_get_error_code
LIBSSH_API int ssh_get_error_code(void *error)
Retrieve the error code from the last error.
Definition error.c:148
ssh_get_error
LIBSSH_API const char * ssh_get_error(void *error)
Retrieve the error text message from the last error.
Definition error.c:128
ssh_connect
LIBSSH_API int ssh_connect(ssh_session session)
Connect to the ssh server.
Definition client.c:528
ssh_get_disconnect_message
LIBSSH_API const char * ssh_get_disconnect_message(ssh_session session)
Get the disconnect message from the server.
Definition session.c:900
ssh_disconnect
LIBSSH_API void ssh_disconnect(ssh_session session)
Disconnect from a session (client or server).
Definition client.c:786
ssh_get_issue_banner
LIBSSH_API char * ssh_get_issue_banner(ssh_session session)
Get the issue banner from the server.
Definition client.c:684
ssh_options_set
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:652
ssh_options_parse_config
LIBSSH_API int ssh_options_parse_config(ssh_session session, const char *filename)
Parse the ssh config file.
Definition options.c:1822
ssh_get_version
LIBSSH_API int ssh_get_version(ssh_session session)
Get the protocol version of the session.
Definition session.c:925
ssh_session_update_known_hosts
LIBSSH_API int ssh_session_update_known_hosts(ssh_session session)
Adds the currently connected server to the user known_hosts file.
Definition knownhosts.c:993
ssh_new
LIBSSH_API ssh_session ssh_new(void)
Create a new ssh session.
Definition session.c:60
ssh_get_openssh_version
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:711
ssh_session_is_known_server
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:1288
ssh_silent_disconnect
LIBSSH_API void ssh_silent_disconnect(ssh_session session)
Disconnect impolitely from a remote host by closing the socket.
Definition session.c:544
ssh_free
LIBSSH_API void ssh_free(ssh_session session)
Deallocate a SSH session handle.
Definition session.c:209
ssh_options_copy
LIBSSH_API int ssh_options_copy(ssh_session src, ssh_session *dest)
Duplicate the options of a session structure.
Definition options.c:68
ssh_get_fd
LIBSSH_API socket_t ssh_get_fd(ssh_session session)
Get the fd of a connection.
Definition session.c:645