libssh  0.10.90
The SSH library
Loading...
Searching...
No Matches
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
61namespace ssh {
62
63class Channel;
68#ifndef SSH_NO_CPP_EXCEPTIONS
69
75public:
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 }
99private:
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
126class Session {
127 friend class Channel;
128public:
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, username, submethods);
216 ssh_throw(ret);
217 return ret;
218 }
219
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 }
271 int userauthTryPublickey(ssh_key pubkey){
272 int ret=ssh_userauth_try_publickey(c_session, NULL, pubkey);
273 ssh_throw(ret);
274 return ret;
275 }
282 int userauthPublickey(ssh_key privkey){
283 int ret=ssh_userauth_publickey(c_session, NULL, privkey);
284 ssh_throw(ret);
285 return ret;
286 }
287
294 int ret=ssh_userauth_list(c_session, NULL);
295 ssh_throw(ret);
296 return ret;
297 }
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 }
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 va_list va;
373
374 va_start(va, format);
375 ssh_vlog(priority, "libsshpp", format, &va);
376 va_end(va);
377 }
378
383 void_throwable optionsCopy(const Session &source){
384 ssh_throw(ssh_options_copy(source.c_session,&c_session));
385 return_throwable;
386 }
392 void_throwable optionsParseConfig(const char *file){
393 ssh_throw(ssh_options_parse_config(c_session,file));
394 return_throwable;
395 }
400 ssh_silent_disconnect(c_session);
401 }
408 int ret = ssh_session_update_known_hosts(c_session);
409 ssh_throw(ret);
410 return ret;
411 }
412
421 inline Channel *acceptForward(int timeout_ms);
422 /* implemented outside the class due Channel references */
423
424 void_throwable cancelForward(const char *address, int port){
425 int err=ssh_channel_cancel_forward(c_session, address, port);
426 ssh_throw(err);
427 return_throwable;
428 }
429
430 void_throwable listenForward(const char *address, int port,
431 int &boundport){
432 int err=ssh_channel_listen_forward(c_session, address, port, &boundport);
433 ssh_throw(err);
434 return_throwable;
435 }
436
437 ssh_session getCSession(){
438 return c_session;
439 }
440
441protected:
442 ssh_session c_session;
443
444private:
445 /* No copy constructor, no = operator */
446 Session(const Session &);
447 Session& operator=(const Session &);
448};
449
454class Channel {
455 friend class Session;
456public:
457 Channel(Session &ssh_session){
458 channel = ssh_channel_new(ssh_session.getCSession());
459 this->session = &ssh_session;
460 }
461 ~Channel(){
462 ssh_channel_free(channel);
463 channel=NULL;
464 }
465
474 Channel *acceptX11(int timeout_ms){
475 ssh_channel x11chan = ssh_channel_accept_x11(channel,timeout_ms);
476 ssh_throw_null(getCSession(),x11chan);
477 Channel *newchan = new Channel(getSession(),x11chan);
478 return newchan;
479 }
486 void_throwable changePtySize(int cols, int rows){
487 int err=ssh_channel_change_pty_size(channel,cols,rows);
488 ssh_throw(err);
489 return_throwable;
490 }
491
496 void_throwable close(){
497 ssh_throw(ssh_channel_close(channel));
498 return_throwable;
499 }
500
501 int getExitStatus(){
502 return ssh_channel_get_exit_status(channel);
503 }
504 Session &getSession(){
505 return *session;
506 }
510 bool isClosed(){
511 return ssh_channel_is_closed(channel) != 0;
512 }
516 bool isEof(){
517 return ssh_channel_is_eof(channel) != 0;
518 }
522 bool isOpen(){
523 return ssh_channel_is_open(channel) != 0;
524 }
525 int openForward(const char *remotehost, int remoteport,
526 const char *sourcehost, int localport=0){
527 int err=ssh_channel_open_forward(channel,remotehost,remoteport,
528 sourcehost, localport);
529 ssh_throw(err);
530 return err;
531 }
532 /* TODO: completely remove this ? */
533 void_throwable openSession(){
534 int err=ssh_channel_open_session(channel);
535 ssh_throw(err);
536 return_throwable;
537 }
538 int poll(bool is_stderr=false){
539 int err=ssh_channel_poll(channel,is_stderr);
540 ssh_throw(err);
541 return err;
542 }
543 int read(void *dest, size_t count){
544 int err;
545 /* handle int overflow */
546 if(count > 0x7fffffff)
547 count = 0x7fffffff;
548 err=ssh_channel_read_timeout(channel,dest,count,false,-1);
549 ssh_throw(err);
550 return err;
551 }
552 int read(void *dest, size_t count, int timeout){
553 int err;
554 /* handle int overflow */
555 if(count > 0x7fffffff)
556 count = 0x7fffffff;
557 err=ssh_channel_read_timeout(channel,dest,count,false,timeout);
558 ssh_throw(err);
559 return err;
560 }
561 int read(void *dest, size_t count, bool is_stderr=false, int timeout=-1){
562 int err;
563 /* handle int overflow */
564 if(count > 0x7fffffff)
565 count = 0x7fffffff;
566 err=ssh_channel_read_timeout(channel,dest,count,is_stderr,timeout);
567 ssh_throw(err);
568 return err;
569 }
570 int readNonblocking(void *dest, size_t count, bool is_stderr=false){
571 int err;
572 /* handle int overflow */
573 if(count > 0x7fffffff)
574 count = 0x7fffffff;
575 err=ssh_channel_read_nonblocking(channel,dest,count,is_stderr);
576 ssh_throw(err);
577 return err;
578 }
579 void_throwable requestEnv(const char *name, const char *value){
580 int err=ssh_channel_request_env(channel,name,value);
581 ssh_throw(err);
582 return_throwable;
583 }
584
585 void_throwable requestExec(const char *cmd){
586 int err=ssh_channel_request_exec(channel,cmd);
587 ssh_throw(err);
588 return_throwable;
589 }
590 void_throwable requestPty(const char *term=NULL, int cols=0, int rows=0){
591 int err;
592 if(term != NULL && cols != 0 && rows != 0)
593 err=ssh_channel_request_pty_size(channel,term,cols,rows);
594 else
595 err=ssh_channel_request_pty(channel);
596 ssh_throw(err);
597 return_throwable;
598 }
599
600 void_throwable requestShell(){
601 int err=ssh_channel_request_shell(channel);
602 ssh_throw(err);
603 return_throwable;
604 }
605 void_throwable requestSendSignal(const char *signum){
606 int err=ssh_channel_request_send_signal(channel, signum);
607 ssh_throw(err);
608 return_throwable;
609 }
610 void_throwable requestSubsystem(const char *subsystem){
611 int err=ssh_channel_request_subsystem(channel,subsystem);
612 ssh_throw(err);
613 return_throwable;
614 }
615 int requestX11(bool single_connection,
616 const char *protocol, const char *cookie, int screen_number){
617 int err=ssh_channel_request_x11(channel,single_connection,
618 protocol, cookie, screen_number);
619 ssh_throw(err);
620 return err;
621 }
622 void_throwable sendEof(){
623 int err=ssh_channel_send_eof(channel);
624 ssh_throw(err);
625 return_throwable;
626 }
636 int write(const void *data, size_t len, bool is_stderr=false){
637 int ret;
638 if(is_stderr){
639 ret=ssh_channel_write_stderr(channel,data,len);
640 } else {
641 ret=ssh_channel_write(channel,data,len);
642 }
643 ssh_throw(ret);
644 return ret;
645 }
646
647 ssh_session getCSession(){
648 return session->getCSession();
649 }
650
651 ssh_channel getCChannel() {
652 return channel;
653 }
654
655protected:
656 Session *session;
657 ssh_channel channel;
658
659private:
660 Channel (Session &ssh_session, ssh_channel c_channel){
661 this->channel=c_channel;
662 this->session = &ssh_session;
663 }
664 /* No copy and no = operator */
665 Channel(const Channel &);
666 Channel &operator=(const Channel &);
667};
668
669
670inline Channel *Session::acceptForward(int timeout_ms){
671 ssh_channel forward =
672 ssh_channel_open_forward_port(c_session, timeout_ms, NULL, NULL, NULL);
673 ssh_throw_null(c_session,forward);
674 Channel *newchan = new Channel(*this,forward);
675 return newchan;
676 }
677
678} // namespace ssh
679
681#endif /* LIBSSHPP_HPP_ */
the ssh::Channel class describes the state of an SSH channel.
Definition libsshpp.hpp:454
int write(const void *data, size_t len, bool is_stderr=false)
Writes on a channel.
Definition libsshpp.hpp:636
void_throwable close()
closes a channel
Definition libsshpp.hpp:496
bool isClosed()
returns true if channel is in closed state
Definition libsshpp.hpp:510
void_throwable changePtySize(int cols, int rows)
change the size of a pseudoterminal
Definition libsshpp.hpp:486
bool isEof()
returns true if channel is in EOF state
Definition libsshpp.hpp:516
bool isOpen()
returns true if channel is in open state
Definition libsshpp.hpp:522
Channel * acceptX11(int timeout_ms)
accept an incoming X11 connection
Definition libsshpp.hpp:474
Definition libsshpp.hpp:126
int getAuthList()
Returns the available authentication methods from the server.
Definition libsshpp.hpp:293
int isServerKnown()
verifies that the server is known
Definition libsshpp.hpp:366
int userauthKbdintGetNPrompts()
Get the number of prompts (questions) the server has given.
Definition libsshpp.hpp:224
int userauthKbdint(const char *username, const char *submethods)
Authenticate through the "keyboard-interactive" method.
Definition libsshpp.hpp:214
void silentDisconnect()
silently disconnect from remote host
Definition libsshpp.hpp:399
void_throwable setOption(enum ssh_options_e type, long int option)
sets an SSH session options
Definition libsshpp.hpp:152
socket_t getSocket()
returns the file descriptor used for the communication
Definition libsshpp.hpp:330
void_throwable setOption(enum ssh_options_e type, void *option)
sets an SSH session options
Definition libsshpp.hpp:162
void_throwable setOption(enum ssh_options_e type, const char *option)
sets an SSH session options
Definition libsshpp.hpp:142
int getVersion()
returns the version of the SSH protocol being used
Definition libsshpp.hpp:357
const char * getDisconnectMessage()
Returns the disconnect message from the server, if any.
Definition libsshpp.hpp:308
int userauthPublickeyAuto(void)
Authenticates automatically using public key.
Definition libsshpp.hpp:180
Channel * acceptForward(int timeout_ms)
accept an incoming forward connection
Definition libsshpp.hpp:670
void_throwable connect()
connects to the remote host
Definition libsshpp.hpp:170
int userauthPublickey(ssh_key privkey)
Authenticates using the publickey method.
Definition libsshpp.hpp:282
int userauthKbdintSetAnswer(unsigned int index, const char *answer)
Set the answer for a question from a message block.
Definition libsshpp.hpp:244
int userauthNone()
Authenticates using the "none" method. Prefer using autopubkey if possible.
Definition libsshpp.hpp:192
std::string getIssueBanner()
gets the Issue banner from the ssh server
Definition libsshpp.hpp:337
int getOpensshVersion()
returns the OpenSSH version (server) if possible
Definition libsshpp.hpp:350
void disconnect()
Disconnects from the SSH server and closes connection.
Definition libsshpp.hpp:301
int userauthPassword(const char *password)
Authenticates using the password method.
Definition libsshpp.hpp:259
void_throwable optionsCopy(const Session &source)
copies options from a session to another
Definition libsshpp.hpp:383
int writeKnownhost()
Writes the known host file with current host key.
Definition libsshpp.hpp:407
void_throwable optionsParseConfig(const char *file)
parses a configuration file for options
Definition libsshpp.hpp:392
int userauthTryPublickey(ssh_key pubkey)
Try to authenticate using the publickey method.
Definition libsshpp.hpp:271
if defined, disable C++ exceptions for libssh c++ wrapper
Definition libsshpp.hpp:74
int getCode()
returns the Error code
Definition libsshpp.hpp:89
std::string getError()
returns the error message of the last exception
Definition libsshpp.hpp:96
LIBSSH_API int ssh_userauth_list(ssh_session session, const char *username)
Get available authentication methods from the server.
Definition auth.c:379
LIBSSH_API int ssh_userauth_password(ssh_session session, const char *username, const char *password)
Try to authenticate by password.
Definition auth.c:1616
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:1272
LIBSSH_API int ssh_userauth_none(ssh_session session, const char *username)
Try to authenticate through the "none" method.
Definition auth.c:409
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:493
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:2042
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:2249
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:623
LIBSSH_API int ssh_userauth_kbdint_getnprompts(ssh_session session)
Get the number of prompts (questions) the server has given.
Definition auth.c:2086
LIBSSH_API int ssh_channel_request_subsystem(ssh_channel channel, const char *subsystem)
Request a subsystem (for example "sftp").
Definition channels.c:2082
LIBSSH_API int ssh_channel_send_eof(ssh_channel channel)
Send an end of file on the channel.
Definition channels.c:1343
LIBSSH_API int ssh_channel_poll(ssh_channel channel, int is_stderr)
Polls a channel for data to read.
Definition channels.c:3217
LIBSSH_API int ssh_channel_close(ssh_channel channel)
Close a channel.
Definition channels.c:1404
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:3047
LIBSSH_API int ssh_channel_request_pty(ssh_channel channel)
Request a PTY.
Definition channels.c:1999
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:2628
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:2609
LIBSSH_API ssh_channel ssh_channel_accept_x11(ssh_channel channel, int timeout_ms)
Accept an X11 forwarding channel.
Definition channels.c:2310
LIBSSH_API int ssh_channel_request_exec(ssh_channel channel, const char *cmd)
Run a shell command without an interactive shell.
Definition channels.c:2751
LIBSSH_API int ssh_channel_write(ssh_channel channel, const void *data, uint32_t len)
Blocking write on a channel.
Definition channels.c:1674
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:2519
LIBSSH_API int ssh_channel_request_env(ssh_channel channel, const char *name, const char *value)
Set environment variables.
Definition channels.c:2680
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:3640
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:3370
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:2817
LIBSSH_API int ssh_channel_is_open(ssh_channel channel)
Check if the channel is open or not.
Definition channels.c:1688
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:3158
LIBSSH_API int ssh_channel_is_closed(ssh_channel channel)
Check if the channel is closed or not.
Definition channels.c:1705
LIBSSH_API int ssh_channel_is_eof(ssh_channel channel)
Check if remote has sent an EOF.
Definition channels.c:1720
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:1935
LIBSSH_API void ssh_channel_free(ssh_channel channel)
Close and free a channel.
Definition channels.c:1242
LIBSSH_API ssh_channel ssh_channel_new(ssh_session session)
Allocate a new channel.
Definition channels.c:90
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:2186
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:1103
LIBSSH_API int ssh_channel_request_shell(ssh_channel channel)
Request a shell.
Definition channels.c:2059
LIBSSH_API int ssh_channel_open_session(ssh_channel channel)
Open a session channel (suited for a shell, not TCP forwarding).
Definition channels.c:1036
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:2019
LIBSSH_API int ssh_get_error_code(void *error)
Retrieve the error code from the last error.
Definition error.c:148
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_connect(ssh_session session)
Connect to the ssh server.
Definition client.c:524
LIBSSH_API const char * ssh_get_disconnect_message(ssh_session session)
Get the disconnect message from the server.
Definition session.c:861
LIBSSH_API void ssh_disconnect(ssh_session session)
Disconnect from a session (client or server).
Definition client.c:771
LIBSSH_API char * ssh_get_issue_banner(ssh_session session)
Get the issue banner from the server.
Definition client.c:668
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:616
LIBSSH_API int ssh_options_parse_config(ssh_session session, const char *filename)
Parse the ssh config file.
Definition options.c:1636
LIBSSH_API int ssh_get_version(ssh_session session)
Get the protocol version of the session.
Definition session.c:886
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
LIBSSH_API ssh_session ssh_new(void)
Create a new ssh session.
Definition session.c:59
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:695
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
LIBSSH_API void ssh_silent_disconnect(ssh_session session)
Disconnect impolitely from a remote host by closing the socket.
Definition session.c:505
LIBSSH_API void ssh_free(ssh_session session)
Deallocate a SSH session handle.
Definition session.c:197
LIBSSH_API int ssh_options_copy(ssh_session src, ssh_session *dest)
Duplicate the options of a session structure.
Definition options.c:68
LIBSSH_API socket_t ssh_get_fd(ssh_session session)
Get the fd of a connection.
Definition session.c:606