static int client(ssh_session session){
int auth=0;
char *banner;
int state;
if (ssh_options_set(session, SSH_OPTIONS_HOST ,host) < 0)
return -1;
ssh_options_parse_config(session, NULL);
if(ssh_connect(session)){
fprintf(stderr,"Connection failed : %s\n",ssh_get_error(session));
return -1;
}
state=verify_knownhost(session);
if (state != 0)
return -1;
ssh_userauth_none(session, NULL);
banner=ssh_get_issue_banner(session);
if(banner){
printf("%s\n",banner);
free(banner);
}
auth=authenticate_console(session);
if(auth != SSH_AUTH_SUCCESS){
return -1;
}
forwarding(session);
return 0;
}
static const gchar *
cockpit_ssh_connect (CockpitSshData *data)
{
const gchar *problem;
int rc;
/*
* If connect_done is set prematurely by another thread then the
* connection attempt was cancelled.
*/
rc = ssh_connect (data->session);
if (rc != SSH_OK)
{
if (g_atomic_int_get (data->connecting))
g_message ("%s: couldn't connect: %s", data->logname,
ssh_get_error (data->session));
return "no-host";
}
g_debug ("%s: connected", data->logname);
if (!data->ignore_key)
{
problem = verify_knownhost (data);
if (problem != NULL)
return problem;
}
/* The problem returned when auth failure */
problem = cockpit_ssh_authenticate (data);
if (problem != NULL)
return problem;
data->channel = ssh_channel_new (data->session);
g_return_val_if_fail (data->channel != NULL, NULL);
rc = ssh_channel_open_session (data->channel);
if (rc != SSH_OK)
{
if (g_atomic_int_get (data->connecting))
g_message ("%s: couldn't open session: %s", data->logname,
ssh_get_error (data->session));
return "internal-error";
}
rc = ssh_channel_request_exec (data->channel, data->command);
if (rc != SSH_OK)
{
if (g_atomic_int_get (data->connecting))
g_message ("%s: couldn't execute command: %s: %s", data->logname,
data->command, ssh_get_error (data->session));
return "internal-error";
}
g_debug ("%s: opened channel", data->logname);
/* Success */
return NULL;
}
static int client(ssh_session_t *session)
{
int auth=0;
char *banner;
int state;
if (user)
{
if (ssh_options_set(session, SSH_OPTIONS_USER, user) < 0)
{
return -1;
}
}
if (ssh_options_set(session, SSH_OPTIONS_HOST ,host) < 0)
{
return -1;
}
if (proxycommand != NULL)
{
if(ssh_options_set(session, SSH_OPTIONS_PROXYCOMMAND, proxycommand))
{
return -1;
}
}
ssh_options_parse_config(session, NULL);
if(ssh_connect(session))
{
fprintf(stderr,"Connection failed : %s\n",ssh_get_error(session));
return -1;
}
state = verify_knownhost(session);
if (state != 0)
{
return -1;
}
ssh_userauth_none(session, NULL);
banner = ssh_get_issue_banner(session);
if(banner)
{
printf("%s\n", banner);
free(banner);
}
auth = authenticate_console(session);
if(auth != SSH_AUTH_SUCCESS)
{
return -1;
}
if(!cmds[0]) {
shell(session);
} else {
batch_shell(session);
}
return 0;
}
// TODO: remove this obsolete
static int client(ssh_session session)
{
int auth=0;
int state;
if (user)
if (ssh_options_set(session, SSH_OPTIONS_USER, user) < 0)
return -1;
if (ssh_options_set(session, SSH_OPTIONS_HOST ,host) < 0)
return -1;
if (proxycommand != NULL)
{
if(ssh_options_set(session, SSH_OPTIONS_PROXYCOMMAND, proxycommand))
return -1;
}
ssh_options_parse_config(session, NULL);
if(ssh_connect(session))
{
fprintf(stderr,"Connection failed : %s\n",ssh_get_error(session));
return -1;
}
state=verify_knownhost(session);
if (state != 0)
return -1;
ssh_userauth_none(session, NULL);
auth=authenticate_console(session);
if(auth != SSH_AUTH_SUCCESS)
{
return -1;
}
shell(session);
return 0;
}
ssh_session connect_ssh(const char *host, const char *user,int verbosity)
{
ssh_session session;
int auth=0;
session=ssh_new();
if(session==NULL) return(NULL);
if(user!=NULL)
{
if(ssh_options_set(session,SSH_OPTIONS_USER,user)<0)
{
ssh_free(session);
return NULL;
}
}
if(ssh_options_set(session,SSH_OPTIONS_HOST,host)<0)
{
ssh_free(session);
return(NULL);
}
ssh_options_set(session,SSH_OPTIONS_LOG_VERBOSITY,&verbosity);
if(ssh_connect(session))
{
prterr("Connection failed : %s\n",ssh_get_error(session));
ssh_disconnect(session);
ssh_free(session);
return(NULL);
}
if(verify_knownhost(session)<0)
{
ssh_disconnect(session);
ssh_free(session);
return(NULL);
}
auth=authenticate_console(session);
if(auth==SSH_AUTH_SUCCESS)
{
return(session);
} else if(auth==SSH_AUTH_DENIED)
{
prterr("Error: Authentication failed.");
} else {
prterr("Error while authenticating : %s\n",ssh_get_error(session));
}
ssh_disconnect(session);
ssh_free(session);
return(NULL);
}
int main(int argc, char **argv) {
// check for args num
if (argc < 3) exit(-1);
// assign first arg to host var
char host[20];
strcpy(host, argv[1]);
// assign second arg to port var
int port = atoi(argv[2]);
// set verbosity if need
// int verbosity = SSH_LOG_FUNCTIONS;
// int verbosity = SSH_LOG_PROTOCOL;
int connection;
ssh_session session;
session = ssh_new();
if (session == NULL) exit(-1);
ssh_options_set(session, SSH_OPTIONS_HOST, host);
// ssh_options_set(session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
ssh_options_set(session, SSH_OPTIONS_PORT, &port);
ssh_options_set(session, SSH_OPTIONS_USER, "gluck");
printf("Connecting to host %s and port %d\n", host, port);
connection = ssh_connect(session);
if (connection != SSH_OK) {
printf("Error connecting to %s: %s\n", host, ssh_get_error(session));
exit -1;
} else {
printf("Connected.\n");
}
if (verify_knownhost(session) < 0) {
ssh_disconnect(session);
ssh_free(session);
exit(-1);
}
int rc;
char *password;
password = getpass("Password: "******"Error authenticating with password: %s\n",
ssh_get_error(session));
ssh_disconnect(session);
ssh_free(session);
exit(-1);
}
if (show_remote_processes(session) != SSH_OK) {
printf("Error executing request\n");
ssh_get_error(session);
ssh_disconnect(session);
ssh_free(session);
exit(-1);
} else {
printf("\nRequest completed successfully!\n");
}
ssh_disconnect(session);
ssh_free(session);
}
int main(int argc, char *argv[])
{
int fuse_stat;
ggnfs_data.remoteHost =argv[1];
ggnfs_data.rootdir = realpath(argv[2], NULL);
printf("hostname -> %s\n", ggnfs_data.remoteHost);
printf("rootdir -> %s\n", ggnfs_data.rootdir);
/* start new ssh session */
int rc;
ggnfs_data.session = ssh_new();
if (ggnfs_data.session == NULL)
exit(-1);
ssh_options_set(ggnfs_data.session, SSH_OPTIONS_HOST, ggnfs_data.remoteHost);
rc = ssh_connect(ggnfs_data.session);
if (rc != SSH_OK)
{
fprintf(stderr, "Error connecting to remoteHost: %s\n",
ssh_get_error(ggnfs_data.session));
ssh_free(ggnfs_data.session);
exit(-1);
}
// Verify the server's identity
// For the source code of verify_knowhost(), check previous example
if (verify_knownhost(ggnfs_data.session) < 0)
{
ssh_disconnect(ggnfs_data.session);
ssh_free(ggnfs_data.session);
exit(-1);
}
// Authenticate ourselves
//char * password = "******";// getpass("Password: "******"Error authenticating with password: %s\n",
ssh_get_error(ggnfs_data.session));
ssh_disconnect(ggnfs_data.session);
ssh_free(ggnfs_data.session);
exit(-1);
}
/** making sftp session **/
int rc_sftp;
ggnfs_data.sftp = sftp_new(ggnfs_data.session);
if (ggnfs_data.sftp == NULL)
{
fprintf(stderr, "Error allocating SFTP session: %s\n",
ssh_get_error(ggnfs_data.session));
// return SSH_ERROR;
}
rc_sftp = sftp_init(ggnfs_data.sftp);
if (rc_sftp != SSH_OK)
{
fprintf(stderr, "Error initializing SFTP session: %s.\n",
sftp_get_error(ggnfs_data.sftp));
sftp_free(ggnfs_data.sftp);
// return rc;
}
/* Adjusting agruments to pass to FUSE mount function*/
int i = 1;
for(; i < argc; ++i) {
argv[i] = argv[i+1];
}
argv[argc-1] = NULL;
argc--;
/*** TESTING: status working ***/
//printf("show_remote_ls\n");
//show_remote_ls(ggnfs_data->session);
sftp_list_dir(ggnfs_data.session, ggnfs_data.sftp);
printf("about to call fuse_main\n");
fuse_stat = fuse_main(argc, argv, &ggnfs_oper, NULL);
printf("fuse_main returned %d\n", fuse_stat);
ssh_disconnect(ggnfs_data.session);
ssh_free(ggnfs_data.session);
sftp_free(ggnfs_data.sftp);
return fuse_stat;
}
ssh_session connect_ssh(const char *host, const char *user,int verbosity)
{
ssh_session session;
int auth=0;
session=ssh_new();
if (NULL == session)
{
return NULL;
}
if(NULL != user)
{
if (ssh_options_set(session, SSH_OPTIONS_USER, user) < 0)
{
ssh_free(session);
return NULL;
}
}
if (ssh_options_set(session, SSH_OPTIONS_HOST, host) < 0)
{
ssh_free(session);
return NULL;
}
ssh_options_set(session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
if(ssh_connect(session))
{
fprintf(stderr,"Connection failed : %s\n",ssh_get_error(session));
ssh_disconnect(session);
ssh_free(session);
return NULL;
}
if(verify_knownhost(session)<0)
{
ssh_disconnect(session);
ssh_free(session);
return NULL;
}
auth=authenticate_console(session);
if(SSH_AUTH_SUCCESS == auth)
{
return session;
}
else
if(SSH_AUTH_DENIED == auth)
{
fprintf(stderr,"Authentication failed\n");
}
else
{
fprintf(stderr,"Error while authenticating : %s\n",ssh_get_error(session));
}
ssh_disconnect(session);
ssh_free(session);
return NULL;
}
int ssh_open_url(url_t* urlp)
{
ftp->session = ssh_new();
if (!ftp->session)
return -1;
/* set log level */
if (ftp_get_verbosity() == vbDebug)
{
int verbosity = SSH_LOG_PROTOCOL;
ssh_options_set(ftp->session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
}
/* If we have ssh options from yafcrc, load them */
if (gvSSHOptions) {
args_t *args = args_create();
args_init(args, 0, NULL);
args_push_back(args, gvSSHOptions);
int argc = 0;
if (ssh_options_getopt(ftp->session, &argc, args->argv) != SSH_OK) {
ftp_err(_("Failed to load SSH options from yafcrc config (ssh_options = '%s')\n"), gvSSHOptions);
ssh_free(ftp->session);
ftp->session = NULL;
return -1;
}
args->argc = argc;
args_destroy(args);
}
/* set host name */
ssh_options_set(ftp->session, SSH_OPTIONS_HOST, urlp->hostname);
/* if we have port use that one */
if (urlp->port > 0)
ssh_options_set(ftp->session, SSH_OPTIONS_PORT, &urlp->port);
/* parse .ssh/config */
int r = ssh_options_parse_config(ftp->session, NULL);
if (r != SSH_OK)
{
ftp_err(_("Failed to parse ssh config: %s\n"), ssh_get_error(ftp->session));
ssh_free(ftp->session);
ftp->session = NULL;
return r;
}
/* if we have username use that one */
if (urlp->username)
ssh_options_set(ftp->session, SSH_OPTIONS_USER, urlp->username);
/* connect to server */
r = ssh_connect(ftp->session);
if (r != SSH_OK)
{
ftp_err(_("Couldn't initialise connection to server: %s\n"), ssh_get_error(ftp->session));
ssh_free(ftp->session);
ftp->session = NULL;
return r;
}
/* verify server */
if (verify_knownhost(ftp->session))
{
ssh_disconnect(ftp->session);
ssh_free(ftp->session);
ftp->session = NULL;
return -1;
}
/* authenticate user */
r = test_several_auth_methods(ftp->session, urlp);
if (r != SSH_OK)
{
ftp_err(_("Authentication failed: %s\n"), ssh_get_error(ftp->session));
ssh_disconnect(ftp->session);
ssh_free(ftp->session);
ftp->session = NULL;
return -1;
}
ftp->ssh_version = ssh_get_version(ftp->session);
if (!ftp->ssh_version) {
ftp_err(_("Couldn't initialise connection to server\n"));
return -1;
}
ftp->sftp_session = sftp_new(ftp->session);
if (!ftp->sftp_session)
{
ftp_err(_("Couldn't initialise ftp subsystem: %s\n"), ssh_get_error(ftp->session));
ssh_disconnect(ftp->session);
ssh_free(ftp->session);
ftp->session = NULL;
return -1;
}
r = sftp_init(ftp->sftp_session);
if (r != SSH_OK)
{
ftp_err(_("Couldn't initialise ftp subsystem: %s\n"), ssh_get_error(ftp->sftp_session));
sftp_free(ftp->sftp_session);
ftp->sftp_session = NULL;
ssh_disconnect(ftp->session);
ssh_free(ftp->session);
ftp->session = NULL;
return r;
}
ftp->connected = true;
ftp->loggedin = true;
free(ftp->homedir);
ftp->homedir = ftp_getcurdir();
url_destroy(ftp->url);
ftp->url = url_clone(urlp);
free(ftp->curdir);
ftp->curdir = xstrdup(ftp->homedir);
free(ftp->prevdir);
ftp->prevdir = xstrdup(ftp->homedir);
if (ftp->url->directory)
ftp_chdir(ftp->url->directory);
ftp_get_feat();
return 0;
}
bool SSH_Socket::onEnter()
{
// For testing and getting debugging output
//int verb = SSH_LOG_PROTOCOL;
int rc;
// Setup new SSH Shell
session = ssh_new();
if(session == nullptr)
{
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION,
"Closed Session", "User has closed the program.", nullptr);
TheSocketHandler::Instance()->setActive(false);
return false;
}
std::cout << "Connecting to: " << host << ":" << port << std::endl;
std::cout << "User: "******"Starting up SSH Connection, this can take few moments" << std::endl;
// SSH Connect
rc = ssh_connect(session);
if(rc != SSH_OK)
{
std::cout << "Error: ssh_connect: " << host
<< " " << ssh_get_error(session) << std::endl;
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION,
"Closed Session", "Unable to Connect to Server!", nullptr);
TheSocketHandler::Instance()->setActive(false);
return false;
}
// Verify Server is a known host.
rc = verify_knownhost();
if(rc < 0)
{
std::cout << "Error: verify_knownhost: " << host
<< " " << ssh_get_error(session) << " " << rc << std::endl;
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION,
"Closed Session", "User has closed the program.", nullptr);
TheSocketHandler::Instance()->setActive(false);
return false;
}
//if ((ssh_userauth_password(session, NULL, password) == SSH_AUTH_SUCCESS)
rc = authenticate_console();
if(rc != SSH_AUTH_SUCCESS)
{
std::cout << "Error: authenticate: " << host
<< " " << ssh_get_error(session) << " " << rc << std::endl;
TheSocketHandler::Instance()->setActive(false);
return false;
}
// Setup Channel for Socket Communications
sshChannel = ssh_channel_new(session);
if(sshChannel == nullptr)
{
std::cout << "Error: ssh_channel_new: " << host
<< " " << ssh_get_error(session) << " " << rc << std::endl;
TheSocketHandler::Instance()->setActive(false);
return false;
}
// Open A shell Session
rc = ssh_channel_open_session(sshChannel);
if(rc != SSH_OK)
{
std::cout << "Error: ssh_channel_open_session: " << host
<< " " << ssh_get_error(session) << " " << rc << std::endl;
TheSocketHandler::Instance()->setActive(false);
return false;
}
/* Don't need this when we use the PTY size, it does both!
// Setup sockets or "channels" within the session
if(ssh_channel_request_pty(sshChannel))
{
printf("\r\n SSH Error, Request for PTY Failed. %s: %s - %i \r\n",
host, ssh_get_error(session), rc);
SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION,
"Closed Session",
"User has closed the program.",
NULL);
onExit();
}*/
// Set the term and pty size of the terminal.
// Only After the Shell has been initialized.
if(ssh_channel_request_pty_size(sshChannel, "ansi", 80, 25))
{
std::cout << "Error: ssh_channel_request_pty_size: " << host
<< " " << ssh_get_error(session) << " " << rc << std::endl;
// Not an error to exit the connection on.
//return 0;
}
// Now request a shell with the pty to get read/write
if(ssh_channel_request_shell(sshChannel))
{
std::cout << "Error: ssh_channel_request_shell: " << host
<< " " << ssh_get_error(session) << " " << rc << std::endl;
TheSocketHandler::Instance()->setActive(false);
return false;
}
return true;
}
