void shell(SSH_SESSION *session){
CHANNEL *channel;
struct termios terminal_local;
int interactive=isatty(0);
channel = channel_new(session);
if(interactive){
tcgetattr(0,&terminal_local);
memcpy(&terminal,&terminal_local,sizeof(struct termios));
}
if(channel_open_session(channel)){
printf("error opening channel : %s\n",ssh_get_error(session));
return;
}
chan=channel;
if(interactive){
channel_request_pty(channel);
sizechanged();
}
if(channel_request_shell(channel)){
printf("Requesting shell : %s\n",ssh_get_error(session));
return;
}
if(interactive){
cfmakeraw(&terminal_local);
tcsetattr(0,TCSANOW,&terminal_local);
setsignal();
}
signal(SIGTERM,do_cleanup);
select_loop(session,channel);
}
void batch_shell(SSH_SESSION *session){
CHANNEL *channel;
char buffer[1024];
int i,s=0;
for(i=0;i<MAXCMD && cmds[i];++i)
s+=snprintf(buffer+s,sizeof(buffer)-s,"%s ",cmds[i]);
channel=channel_new(session);
channel_open_session(channel);
if(channel_request_exec(channel,buffer)){
printf("error executing \"%s\" : %s\n",buffer,ssh_get_error(session));
return;
}
select_loop(session,channel);
}
// Connect to a SSH server.
// When the connection is established, read data from stdin and send it to the server.
void client_pipe(char *host, int port)
{
ssh_session s = ssh_new();
ssh_options_set(s, SSH_OPTIONS_HOST, host);
ssh_options_set(s, SSH_OPTIONS_PORT, &port);
ssh_options_set(s, SSH_OPTIONS_USER, "xya");
//ssh_options_set(s, SSH_OPTIONS_LOG_VERBOSITY_STR, "5");
if(ssh_connect(s) != SSH_OK)
return session_error(s, "connect");
char *hash = pubkey_hash(ssh_get_pubkey(s));
if(authenticate(hash, 0))
{
session_event(s, "authenticated", hash);
free(hash);
}
else
{
free(hash);
exit(1);
}
int keytype;
ssh_string pub = publickey_from_file(s, "test-client-key.pub", &keytype);
if(!pub)
session_error(s, "open-public-key");
if(SSH_AUTH_SUCCESS != ssh_userauth_offer_pubkey(s, NULL, keytype, pub))
session_error(s, "offer-public-key");
ssh_private_key priv = privatekey_from_file(s, "test-client-key", keytype, NULL);
if(!priv)
session_error(s, "open-private-key");
if(SSH_AUTH_SUCCESS != ssh_userauth_pubkey(s, NULL, pub, priv))
session_error(s, "user-auth");
string_free(pub);
privatekey_free(priv);
ssh_channel chan = channel_new(s);
if(!chan)
session_error(s, "create-channel");
if(channel_open_session(chan) < 0)
session_error(s, "open-channel");
session_event(s, "channel-opened", NULL);
channel_from_file(chan, 0);
channel_free(chan);
ssh_disconnect(s);
ssh_finalize();
}
int ssh_scp_init(ssh_scp scp){
int r;
char execbuffer[1024];
uint8_t code;
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(scp->session,SSH_LOG_PROTOCOL,"Initializing scp session %s %son location '%s'",
scp->mode==SSH_SCP_WRITE?"write":"read",
scp->recursive?"recursive ":"",
scp->location);
scp->channel=channel_new(scp->session);
if(scp->channel == NULL){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
r= 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(channel_request_exec(scp->channel,execbuffer) == SSH_ERROR){
scp->state=SSH_SCP_ERROR;
return SSH_ERROR;
}
if(scp->mode == SSH_SCP_WRITE){
r=channel_read(scp->channel,&code,1,0);
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 {
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;
}
ssh_channel
SSHClient::openChannel(ssh_session session)
{
// GNASH_REPORT_FUNCTION;
if (session) {
_channel = channel_new(session);
if (_channel) {
if (channel_open_session(_channel) != SSH_OK) {
log_error(_("Can't open the SSH channel!"));
}
} else {
log_error(_("Can't allocate memory for new SSH channel!"));
}
}
return _channel;
}
static void create_files(ssh_session session){
ssh_channel channel=channel_new(session);
char buffer[1];
if(channel == NULL){
fprintf(stderr,"Error creating channel: %s\n",ssh_get_error(session));
exit(EXIT_FAILURE);
}
if(channel_open_session(channel) != SSH_OK){
fprintf(stderr,"Error creating channel: %s\n",ssh_get_error(session));
exit(EXIT_FAILURE);
}
if(channel_request_exec(channel,createcommand) != SSH_OK){
fprintf(stderr,"Error executing command: %s\n",ssh_get_error(session));
exit(EXIT_FAILURE);
}
while(!channel_is_eof(channel)){
channel_read(channel,buffer,1,1);
write(1,buffer,1);
}
channel_close(channel);
channel_free(channel);
}
static gpointer
remmina_ssh_tunnel_main_thread_proc (gpointer data)
{
RemminaSSHTunnel *tunnel = (RemminaSSHTunnel*) data;
gchar *ptr;
ssize_t len = 0, lenw = 0;
fd_set set;
struct timeval timeout;
GTimeVal t1, t2;
glong diff;
ssh_channel channel = NULL;
gboolean first = TRUE;
gboolean disconnected;
gint sock;
gint maxfd;
gint i;
gint ret;
struct sockaddr_in sin;
g_get_current_time (&t1);
t2 = t1;
switch (tunnel->tunnel_type)
{
case REMMINA_SSH_TUNNEL_OPEN:
/* Accept a local connection */
sock = accept (tunnel->server_sock, NULL, NULL);
if (sock < 0)
{
REMMINA_SSH (tunnel)->error = g_strdup ("Failed to accept local socket");
tunnel->thread = 0;
return NULL;
}
if ((channel = channel_new (tunnel->ssh.session)) == NULL)
{
close (sock);
remmina_ssh_set_error (REMMINA_SSH (tunnel), "Failed to createt channel : %s");
tunnel->thread = 0;
return NULL;
}
/* Request the SSH server to connect to the destination */
if (channel_open_forward (channel, tunnel->dest, tunnel->port, "127.0.0.1", 0) != SSH_OK)
{
close (sock);
channel_close (channel);
channel_free (channel);
remmina_ssh_set_error (REMMINA_SSH (tunnel), _("Failed to connect to the SSH tunnel destination: %s"));
tunnel->thread = 0;
return NULL;
}
remmina_ssh_tunnel_add_channel (tunnel, channel, sock);
break;
case REMMINA_SSH_TUNNEL_X11:
if ((tunnel->x11_channel = channel_new (tunnel->ssh.session)) == NULL)
{
remmina_ssh_set_error (REMMINA_SSH (tunnel), "Failed to create channel : %s");
tunnel->thread = 0;
return NULL;
}
if (!remmina_public_get_xauth_cookie (tunnel->localdisplay, &ptr))
{
remmina_ssh_set_application_error (REMMINA_SSH (tunnel), "%s", ptr);
g_free(ptr);
tunnel->thread = 0;
return NULL;
}
if (channel_open_session (tunnel->x11_channel) ||
channel_request_x11 (tunnel->x11_channel, TRUE, NULL, ptr,
gdk_screen_get_number (gdk_screen_get_default ())))
{
g_free(ptr);
remmina_ssh_set_error (REMMINA_SSH (tunnel), "Failed to open channel : %s");
tunnel->thread = 0;
return NULL;
}
g_free(ptr);
if (channel_request_exec (tunnel->x11_channel, tunnel->dest))
{
ptr = g_strdup_printf(_("Failed to execute %s on SSH server : %%s"), tunnel->dest);
remmina_ssh_set_error (REMMINA_SSH (tunnel), ptr);
g_free(ptr);
tunnel->thread = 0;
return NULL;
}
if (tunnel->init_func &&
! (*tunnel->init_func) (tunnel, tunnel->callback_data))
{
if (tunnel->disconnect_func)
{
(*tunnel->disconnect_func) (tunnel, tunnel->callback_data);
}
tunnel->thread = 0;
return NULL;
}
break;
case REMMINA_SSH_TUNNEL_XPORT:
/* Detect the next available port starting from 6010 on the server */
for (i = 10; i <= MAX_X_DISPLAY_NUMBER; i++)
{
if (channel_forward_listen (REMMINA_SSH (tunnel)->session,
(tunnel->bindlocalhost ? "localhost" : NULL), 6000 + i, NULL))
{
continue;
}
else
{
tunnel->remotedisplay = i;
break;
}
}
if (tunnel->remotedisplay < 1)
{
remmina_ssh_set_error (REMMINA_SSH (tunnel), _("Failed to request port forwarding : %s"));
if (tunnel->disconnect_func)
{
(*tunnel->disconnect_func) (tunnel, tunnel->callback_data);
}
tunnel->thread = 0;
return NULL;
}
if (tunnel->init_func &&
! (*tunnel->init_func) (tunnel, tunnel->callback_data))
{
if (tunnel->disconnect_func)
{
(*tunnel->disconnect_func) (tunnel, tunnel->callback_data);
}
tunnel->thread = 0;
return NULL;
}
break;
case REMMINA_SSH_TUNNEL_REVERSE:
if (channel_forward_listen (REMMINA_SSH (tunnel)->session, NULL, tunnel->port, NULL))
{
remmina_ssh_set_error (REMMINA_SSH (tunnel), _("Failed to request port forwarding : %s"));
if (tunnel->disconnect_func)
{
(*tunnel->disconnect_func) (tunnel, tunnel->callback_data);
}
tunnel->thread = 0;
return NULL;
}
if (tunnel->init_func &&
! (*tunnel->init_func) (tunnel, tunnel->callback_data))
{
if (tunnel->disconnect_func)
{
(*tunnel->disconnect_func) (tunnel, tunnel->callback_data);
}
tunnel->thread = 0;
return NULL;
}
break;
}
tunnel->buffer_len = 10240;
tunnel->buffer = g_malloc (tunnel->buffer_len);
/* Start the tunnel data transmittion */
while (tunnel->running)
{
if (tunnel->tunnel_type == REMMINA_SSH_TUNNEL_XPORT ||
tunnel->tunnel_type == REMMINA_SSH_TUNNEL_X11 ||
tunnel->tunnel_type == REMMINA_SSH_TUNNEL_REVERSE)
{
if (first)
{
first = FALSE;
/* Wait for a period of time for the first incoming connection */
if (tunnel->tunnel_type == REMMINA_SSH_TUNNEL_X11)
{
channel = channel_accept_x11 (tunnel->x11_channel, 15000);
}
else
{
channel = channel_forward_accept (REMMINA_SSH (tunnel)->session, 15000);
}
if (!channel)
{
remmina_ssh_set_application_error (REMMINA_SSH (tunnel), _("No response from the server."));
if (tunnel->disconnect_func)
{
(*tunnel->disconnect_func) (tunnel, tunnel->callback_data);
}
tunnel->thread = 0;
return NULL;
}
if (tunnel->connect_func)
{
(*tunnel->connect_func) (tunnel, tunnel->callback_data);
}
if (tunnel->tunnel_type == REMMINA_SSH_TUNNEL_REVERSE)
{
/* For reverse tunnel, we only need one connection. */
channel_forward_cancel (REMMINA_SSH (tunnel)->session, NULL, tunnel->port);
}
}
else if (tunnel->tunnel_type != REMMINA_SSH_TUNNEL_REVERSE)
{
/* Poll once per some period of time if no incoming connections.
* Don't try to poll continuously as it will significantly slow down the loop */
g_get_current_time (&t1);
diff = (t1.tv_sec - t2.tv_sec) * 10 + (t1.tv_usec - t2.tv_usec) / 100000;
if (diff > 1)
{
if (tunnel->tunnel_type == REMMINA_SSH_TUNNEL_X11)
{
channel = channel_accept_x11 (tunnel->x11_channel, 0);
}
else
{
channel = channel_forward_accept (REMMINA_SSH (tunnel)->session, 0);
}
if (channel == NULL)
{
t2 = t1;
}
}
}
if (channel)
{
if (tunnel->tunnel_type == REMMINA_SSH_TUNNEL_REVERSE)
{
sin.sin_family = AF_INET;
sin.sin_port = htons (tunnel->localport);
sin.sin_addr.s_addr = inet_addr ("127.0.0.1");
sock = socket (AF_INET, SOCK_STREAM, 0);
if (connect (sock, (struct sockaddr *) &sin, sizeof (sin)) < 0)
{
remmina_ssh_set_application_error (REMMINA_SSH (tunnel),
"Cannot connect to local port %i.", tunnel->localport);
close (sock);
sock = -1;
}
}
else
{
sock = remmina_public_open_xdisplay (tunnel->localdisplay);
}
if (sock >= 0)
{
remmina_ssh_tunnel_add_channel (tunnel, channel, sock);
}
else
{
/* Failed to create unix socket. Will this happen? */
channel_close (channel);
channel_free (channel);
}
channel = NULL;
}
}
if (tunnel->num_channels <= 0)
{
/* No more connections. We should quit */
break;
}
timeout.tv_sec = 0;
timeout.tv_usec = 200000;
FD_ZERO (&set);
maxfd = 0;
for (i = 0; i < tunnel->num_channels; i++)
{
if (tunnel->sockets[i] > maxfd)
{
maxfd = tunnel->sockets[i];
}
FD_SET (tunnel->sockets[i], &set);
}
ret = ssh_select (tunnel->channels, tunnel->channels_out, maxfd + 1, &set, &timeout);
if (!tunnel->running) break;
if (ret == SSH_EINTR) continue;
if (ret == -1) break;
i = 0;
while (tunnel->running && i < tunnel->num_channels)
{
disconnected = FALSE;
if (FD_ISSET (tunnel->sockets[i], &set))
{
while (!disconnected &&
(len = read (tunnel->sockets[i], tunnel->buffer, tunnel->buffer_len)) > 0)
{
for (ptr = tunnel->buffer, lenw = 0; len > 0; len -= lenw, ptr += lenw)
{
lenw = channel_write (tunnel->channels[i], (char*) ptr, len);
if (lenw <= 0)
{
disconnected = TRUE;
break;
}
}
}
if (len == 0) disconnected = TRUE;
}
if (disconnected)
{
remmina_ssh_tunnel_remove_channel (tunnel, i);
continue;
}
i++;
}
if (!tunnel->running) break;
i = 0;
while (tunnel->running && i < tunnel->num_channels)
{
disconnected = FALSE;
if (!tunnel->socketbuffers[i])
{
len = channel_poll (tunnel->channels[i], 0);
if (len == SSH_ERROR || len == SSH_EOF)
{
disconnected = TRUE;
}
else if (len > 0)
{
tunnel->socketbuffers[i] = remmina_ssh_tunnel_buffer_new (len);
len = channel_read_nonblocking (tunnel->channels[i], tunnel->socketbuffers[i]->data, len, 0);
if (len <= 0)
{
disconnected = TRUE;
}
else
{
tunnel->socketbuffers[i]->len = len;
}
}
}
if (!disconnected && tunnel->socketbuffers[i])
{
for (lenw = 0; tunnel->socketbuffers[i]->len > 0;
tunnel->socketbuffers[i]->len -= lenw, tunnel->socketbuffers[i]->ptr += lenw)
{
lenw = write (tunnel->sockets[i], tunnel->socketbuffers[i]->ptr, tunnel->socketbuffers[i]->len);
if (lenw == -1 && errno == EAGAIN && tunnel->running)
{
/* Sometimes we cannot write to a socket (always EAGAIN), probably because it's internal
* buffer is full. We need read the pending bytes from the socket first. so here we simply
* break, leave the buffer there, and continue with other data */
break;
}
if (lenw <= 0)
{
disconnected = TRUE;
break;
}
}
if (tunnel->socketbuffers[i]->len <= 0)
{
remmina_ssh_tunnel_buffer_free (tunnel->socketbuffers[i]);
tunnel->socketbuffers[i] = NULL;
}
}
if (disconnected)
{
remmina_ssh_tunnel_remove_channel (tunnel, i);
continue;
}
i++;
}
}
remmina_ssh_tunnel_close_all_channels (tunnel);
return NULL;
}
static gpointer
remmina_ssh_shell_thread (gpointer data)
{
RemminaSSHShell *shell = (RemminaSSHShell*) data;
fd_set fds;
struct timeval timeout;
ssh_channel channel = NULL;
ssh_channel ch[2], chout[2];
gchar *buf = NULL;
gint buf_len;
gint len;
gint i, ret;
LOCK_SSH (shell)
if ((channel = channel_new (REMMINA_SSH (shell)->session)) == NULL ||
channel_open_session (channel))
{
UNLOCK_SSH (shell)
remmina_ssh_set_error (REMMINA_SSH (shell), "Failed to open channel : %s");
if (channel) channel_free (channel);
shell->thread = 0;
return NULL;
}
channel_request_pty (channel);
if (shell->exec && shell->exec[0])
{
ret = channel_request_exec (channel, shell->exec);
}
else
{
ret = channel_request_shell (channel);
}
if (ret)
{
UNLOCK_SSH (shell)
remmina_ssh_set_error (REMMINA_SSH (shell), "Failed to request shell : %s");
channel_close (channel);
channel_free (channel);
shell->thread = 0;
return NULL;
}
shell->channel = channel;
UNLOCK_SSH (shell)
buf_len = 1000;
buf = g_malloc (buf_len + 1);
ch[0] = channel;
ch[1] = NULL;
while (!shell->closed)
{
timeout.tv_sec = 1;
timeout.tv_usec = 0;
FD_ZERO (&fds);
FD_SET (shell->master, &fds);
ret = ssh_select (ch, chout, shell->master + 1, &fds, &timeout);
if (ret == SSH_EINTR) continue;
if (ret == -1) break;
if (FD_ISSET (shell->master, &fds))
{
len = read (shell->master, buf, buf_len);
if (len <= 0) break;
LOCK_SSH (shell)
channel_write (channel, buf, len);
UNLOCK_SSH (shell)
}
for (i = 0; i < 2; i++)
{
LOCK_SSH (shell)
len = channel_poll (channel, i);
UNLOCK_SSH (shell)
if (len == SSH_ERROR || len == SSH_EOF)
{
shell->closed = TRUE;
break;
}
if (len <= 0) continue;
if (len > buf_len)
{
buf_len = len;
buf = (gchar*) g_realloc (buf, buf_len + 1);
}
LOCK_SSH (shell)
len = channel_read_nonblocking (channel, buf, len, i);
UNLOCK_SSH (shell)
if (len <= 0)
{
shell->closed = TRUE;
break;
}
while (len > 0)
{
ret = write (shell->master, buf, len);
if (ret <= 0) break;
len -= ret;
}
}
}
gboolean remmina_nx_session_open(RemminaNXSession *nx, const gchar *server, guint port, const gchar *private_key_file,
RemminaNXPassphraseCallback passphrase_func, gpointer userdata)
{
gint ret;
ssh_private_key privkey;
ssh_public_key pubkey;
ssh_string pubkeystr;
gint keytype;
gboolean encrypted;
gchar *passphrase = NULL;
gchar tmpfile[L_tmpnam + 1];
nx ->session = ssh_new();
ssh_options_set(nx->session, SSH_OPTIONS_HOST, server);
ssh_options_set(nx->session, SSH_OPTIONS_PORT, &port);
ssh_options_set(nx->session, SSH_OPTIONS_USER, "nx");
if (private_key_file && private_key_file[0])
{
if (!remmina_get_keytype(private_key_file, &keytype, &encrypted))
{
remmina_nx_session_set_application_error(nx, "Invalid private key file.");
return FALSE;
}
if (encrypted && !passphrase_func(&passphrase, userdata))
{
return FALSE;
}
privkey = privatekey_from_file(nx->session, private_key_file, keytype, (passphrase ? passphrase : ""));
g_free(passphrase);
}
else
{
/* Use NoMachine's default nx private key */
if ((tmpnam(tmpfile)) == NULL || !g_file_set_contents(tmpfile, nx_default_private_key, -1, NULL))
{
remmina_nx_session_set_application_error(nx, "Failed to create temporary private key file.");
return FALSE;
}
privkey = privatekey_from_file(nx->session, tmpfile, REMMINA_SSH_TYPE_DSS, "");
g_unlink(tmpfile);
}
if (privkey == NULL)
{
remmina_nx_session_set_error(nx, "Invalid private key file: %s");
return FALSE;
}
pubkey = publickey_from_privatekey(privkey);
pubkeystr = publickey_to_string(pubkey);
publickey_free(pubkey);
if (ssh_connect(nx->session))
{
string_free(pubkeystr);
privatekey_free(privkey);
remmina_nx_session_set_error(nx, "Failed to startup SSH session: %s");
return FALSE;
}
ret = ssh_userauth_pubkey(nx->session, NULL, pubkeystr, privkey);
string_free(pubkeystr);
privatekey_free(privkey);
if (ret != SSH_AUTH_SUCCESS)
{
remmina_nx_session_set_error(nx, "NX SSH authentication failed: %s");
return FALSE;
}
if ((nx->channel = channel_new(nx->session)) == NULL || channel_open_session(nx->channel))
{
return FALSE;
}
if (channel_request_shell(nx->channel))
{
return FALSE;
}
/* NX server starts the session with an initial 105 status */
if (!remmina_nx_session_expect_status(nx, 105))
return FALSE;
/* Say hello to the NX server */
remmina_nx_session_send_command(nx, "HELLO NXCLIENT - Version %s", nx->version);
if (!remmina_nx_session_expect_status(nx, 105))
return FALSE;
/* Set the NX session environment */
remmina_nx_session_send_command(nx, "SET SHELL_MODE SHELL");
if (!remmina_nx_session_expect_status(nx, 105))
return FALSE;
remmina_nx_session_send_command(nx, "SET AUTH_MODE PASSWORD");
if (!remmina_nx_session_expect_status(nx, 105))
return FALSE;
nx->server = g_strdup(server);
return TRUE;
}
/**
* Launch a command over SSH
* @param QString command The command to launch
* @return bool true if it's ok, false else
*/
bool Kssh::launch(QString command)
{
this->init();
this->m_command = command;
int result;
ssh_channel channel = channel_new(this->m_session);
if (channel == NULL) {
Klog::error(QString("Impossible to open a new channel") + QString(ssh_get_error(this->m_session)));
ssh_disconnect(this->m_session);
ssh_finalize();
return false;
}
if (channel_open_session(channel) == SSH_ERROR) {
Klog::error(QString("Impossible to open a session in the channel") + QString(ssh_get_error(this->m_session)));
channel_close(channel);
ssh_disconnect(this->m_session);
ssh_finalize();
return false;
}
result = channel_request_exec(channel, this->m_command.toStdString().c_str());
if (result == SSH_ERROR) {
Klog::error(QString("Impossible to launch command : ") + QString(ssh_get_error(this->m_session)));
channel_close(channel);
ssh_disconnect(this->m_session);
ssh_finalize();
return false;
} else {
#ifdef DEBUG
Klog::debug(QString("Execution de la commande : ") + this->m_command);
#endif
// read the buffer
char *buf = NULL;
buf = new char[512];
int rc = 0;
do {
if (channel_is_open(channel)) {
rc = channel_read(channel, buf, sizeof(buf), 0);
if (rc > 0) {
this->m_return += QString::fromLatin1(buf, rc);
}
}
} while (rc > 0);
delete[] buf;
channel_send_eof(channel);
channel_close(channel);
ssh_disconnect(this->m_session);
ssh_finalize();
}
return true;
}
