int logon(char* username, char* pass, LIBSSH2_SESSION **session, int sock)
{
int rc;
/* Create a session instance */
if((*session = libssh2_session_init()) == NULL) return -1;
//libssh2_session_set_blocking(*session, 0);
libssh2_session_set_blocking(*session, 1);
//while ((rc = libssh2_session_handshake(*session, sock)) == LIBSSH2_ERROR_EAGAIN);
rc = libssh2_session_handshake(*session, sock);
if(rc)
{
fprintf(stderr, "Failure establishing SSH session: %d %s\n", rc, strerror(errno));
return -1;
}
// while ((rc = libssh2_userauth_password(*session, username, pass)) == LIBSSH2_ERROR_EAGAIN);
rc = libssh2_userauth_password(*session, username, pass);
if (rc)
{
fprintf(stderr, "Authentication by password failed.\n");
if(*session != NULL)
{
libssh2_session_disconnect(*session, "");
libssh2_session_free(*session);
}
close(sock);
libssh2_exit();
return 0;
}
}
/* {{{ session_close
*/
int
Session_close(PYLIBSSH2_SESSION *self)
{
PRINTFUNCNAME
int rc;
char *reason = "end";
PyObject *item;
if(self->opened) {
while(PySet_Size(self->sftps)) {
item = PySet_Pop(self->sftps);
Sftp_shutdown((PYLIBSSH2_SFTP*)item);
Py_XDECREF(item);
}
while(PySet_Size(self->channels)) {
item = PySet_Pop(self->channels);
Channel_close((PYLIBSSH2_CHANNEL*)item);
Py_XDECREF(item);
}
while(PySet_Size(self->listeners)) {
item = PySet_Pop(self->listeners);
Py_XDECREF(item);
}
Py_BEGIN_ALLOW_THREADS
rc = libssh2_session_disconnect(self->session, reason);
Py_END_ALLOW_THREADS
self->opened = 0;
return rc;
}
return 0;
}
void getClient(char * serverAddress) {
int sockFd = makeSocketOrDie();
struct addrinfo * serverInfo = getServerInfo(serverAddress);
printf("Connecting to server\n");
connectOrDie(sockFd, serverInfo);
printf("Connected to server. Making LIBSSH2 session\n");
LIBSSH2_SESSION * session = makeSession();
libssh2_session_set_blocking(session, 1);
libssh2_session_set_timeout(session, 5000);
printf("Made session, handshaking\n");
int result = libssh2_session_handshake(session, sockFd);
//const char * fingerprint = libssh2_hostkey_hash(session, LIBSSH_HOSTKEY_HASH_SHA1);
//TODO: Match the fingerprint against something.
if (result) {
char * errorMessage;
libssh2_session_last_error(session, &errorMessage, NULL, 0);
fprintf(stderr, "Error %s handshaking\n", errorMessage);
exit(EXIT_FAILURE);
}
printf("Handshake completed, making SFTP Session\n");
libssh2_userauth_password(session, NETID, PWD);
LIBSSH2_SFTP * sftpSession = makeSFTPSession(session);
printf("Started SFTP - Downloading file\n");
LIBSSH2_SFTP_HANDLE * fileHandle = libssh2_sftp_open(sftpSession, serverFilePath, LIBSSH2_FXF_READ, 0);
readFile(session, sftpSession, fileHandle);
libssh2_sftp_shutdown(sftpSession);
libssh2_session_disconnect(session, "Done.\n");
libssh2_session_free(session);
freeaddrinfo(serverInfo);
close(sockFd);
}
void CEasyssh::DisconnectAP()
{
libssh2_session_disconnect(m_ssh_session, "Normal Shutdown, Thank you for playing");
libssh2_session_free(m_ssh_session);
closesocket(m_sock);
libssh2_exit();
}
void redisFree(redisContext *c) {
if (c == NULL)
return;
#ifdef FASTO
if(c->channel != NULL){
libssh2_channel_free(c->channel);
}
if(c->session != NULL){
libssh2_session_disconnect(c->session, "Client disconnecting normally");
libssh2_session_free(c->session);
}
#endif
if (c->fd > 0)
close(c->fd);
if (c->obuf != NULL)
sdsfree(c->obuf);
if (c->reader != NULL)
redisReaderFree(c->reader);
if (c->tcp.host)
free(c->tcp.host);
if (c->tcp.source_addr)
free(c->tcp.source_addr);
if (c->unix_sock.path)
free(c->unix_sock.path);
if (c->timeout)
free(c->timeout);
free(c);
}
static void php_ssh2_session_dtor(zend_resource *rsrc)
{
LIBSSH2_SESSION *session = (LIBSSH2_SESSION*)rsrc->ptr;
php_ssh2_session_data **data = (php_ssh2_session_data**)libssh2_session_abstract(session);
libssh2_session_disconnect(session, "PECL/ssh2 (http://pecl.php.net/packages/ssh2)");
if (*data) {
if ((*data)->ignore_cb) {
zval_ptr_dtor((*data)->ignore_cb);
}
if ((*data)->debug_cb) {
zval_ptr_dtor((*data)->debug_cb);
}
if ((*data)->macerror_cb) {
zval_ptr_dtor((*data)->macerror_cb);
}
if ((*data)->disconnect_cb) {
zval_ptr_dtor((*data)->disconnect_cb);
}
closesocket((*data)->socket);
efree(*data);
*data = NULL;
}
libssh2_session_free(session);
}
static void ssh_stream_free(git_smart_subtransport_stream *stream)
{
ssh_stream *s = (ssh_stream *)stream;
ssh_subtransport *t;
if (!stream)
return;
t = OWNING_SUBTRANSPORT(s);
t->current_stream = NULL;
if (s->channel) {
libssh2_channel_close(s->channel);
libssh2_channel_free(s->channel);
s->channel = NULL;
}
if (s->session) {
libssh2_session_disconnect(s->session, "closing transport");
libssh2_session_free(s->session);
s->session = NULL;
}
if (s->io) {
git_stream_close(s->io);
git_stream_free(s->io);
s->io = NULL;
}
git__free(s->url);
git__free(s);
}
CURLcode Curl_scp_done(struct connectdata *conn, CURLcode status,
bool premature)
{
struct SSHPROTO *scp = conn->data->reqdata.proto.ssh;
(void)premature; /* not used */
Curl_safefree(scp->path);
scp->path = NULL;
if (scp->ssh_channel) {
if (libssh2_channel_close(scp->ssh_channel) < 0) {
infof(conn->data, "Failed to stop libssh2 channel subsystem\n");
}
}
if (scp->ssh_session) {
libssh2_session_disconnect(scp->ssh_session, "Shutdown");
libssh2_session_free(scp->ssh_session);
scp->ssh_session = NULL;
}
free(conn->data->reqdata.proto.ssh);
conn->data->reqdata.proto.ssh = NULL;
Curl_pgrsDone(conn);
(void)status; /* unused */
return CURLE_OK;
}
static void
virNetSSHSessionDispose(void *obj)
{
virNetSSHSessionPtr sess = obj;
VIR_DEBUG("sess=0x%p", sess);
if (!sess)
return;
if (sess->channel) {
libssh2_channel_send_eof(sess->channel);
libssh2_channel_close(sess->channel);
libssh2_channel_free(sess->channel);
}
libssh2_knownhost_free(sess->knownHosts);
libssh2_agent_free(sess->agent);
if (sess->session) {
libssh2_session_disconnect(sess->session,
"libvirt: virNetSSHSessionFree()");
libssh2_session_free(sess->session);
}
virNetSSHSessionAuthMethodsFree(sess);
VIR_FREE(sess->channelCommand);
VIR_FREE(sess->hostname);
VIR_FREE(sess->knownHostsFile);
VIR_FREE(sess->authPath);
}
/*
* Deallocate the memory used by the Session object
*
* Arguments: self - The Session object
* Returns: None
*/
static void
session_dealloc(SSH2_SessionObj *self)
{
if (self->opened) {
Py_BEGIN_ALLOW_THREADS
while (libssh2_session_disconnect(self->session, "") == LIBSSH2_ERROR_EAGAIN) {}
Py_END_ALLOW_THREADS
}
static int
netsnmp_ssh_close(netsnmp_transport *t)
{
int rc = -1;
netsnmp_ssh_addr_pair *addr_pair = NULL;
if (t != NULL && t->data != NULL) {
addr_pair = (netsnmp_ssh_addr_pair *) t->data;
}
if (t != NULL && addr_pair && t->sock >= 0) {
DEBUGMSGTL(("ssh", "close fd %d\n", t->sock));
if (addr_pair->channel) {
libssh2_channel_close(addr_pair->channel);
libssh2_channel_free(addr_pair->channel);
addr_pair->channel = NULL;
}
if (addr_pair->session) {
libssh2_session_disconnect(addr_pair->session, "Normal Shutdown");
libssh2_session_free(addr_pair->session);
addr_pair->session = NULL;
}
#ifndef HAVE_CLOSESOCKET
rc = close(t->sock);
#else
rc = closesocket(t->sock);
#endif
t->sock = -1;
#ifdef SNMPSSHDOMAIN_USE_EXTERNAL_PIPE
if (!addr_pair->session && !addr_pair->channel) {
/* XXX: make configurable */
unlink(addr_pair->socket_path);
}
#else /* we're called directly by sshd and use stdin/out */
/* on the server: close stdin/out */
close(STDIN_FILENO);
close(STDOUT_FILENO);
#endif /* ! SNMPSSHDOMAIN_USE_EXTERNAL_PIPE */
} else {
#ifndef SNMPSSHDOMAIN_USE_EXTERNAL_PIPE
/* on the server: close stdin/out */
close(STDIN_FILENO);
close(STDOUT_FILENO);
#endif /* ! SNMPSSHDOMAIN_USE_EXTERNAL_PIPE */
}
return rc;
}
static void freeConnection(const SFtpConnectionCache::SFtpConnection *conn)
{
libssh2_sftp_shutdown(conn->sftp_session);
libssh2_session_disconnect(conn->session, "Normal Shutdown");
libssh2_session_free(conn->session);
closesocket(conn->sock);
delete(conn);
}
/**
* seashell_tunnel_free (struct seashell_connection* conn)
* Closes the tunnel connection.
*
* Arguments:
* conn - Connection to close.
*/
void seashell_tunnel_free (struct seashell_connection* conn) {
if (conn) {
libssh2_channel_free(conn->channel);
libssh2_session_disconnect(conn->session, "Seashell's done!");
libssh2_session_free(conn->session);
close(conn->sockfd);
free(conn);
}
}
void guac_common_ssh_destroy_session(guac_common_ssh_session* session) {
/* Disconnect and clean up libssh2 */
libssh2_session_disconnect(session->session, "Bye");
libssh2_session_free(session->session);
/* Free all other data */
free(session);
}
int Parser::closeSession()
{
if(socket_->isOpen())
socket_->disconnectFromHost();
socket_->deleteLater();
socket_=0;
libssh2_session_disconnect(session_, "Client disconnecting normally");
libssh2_session_free(session_);
libssh2_exit();
return 1;
}
~SSH2() {
if (mSessionOK) {
libssh2_session_disconnect(mSession, "Goodbye from SilkJS");
libssh2_session_free(mSession);
}
if (mSock > 0) {
close(mSock);
mSock = -1;
}
#ifdef libssh2_exit
libssh2_exit();
#endif
}
/* sftp协议断开连接 */
static void sftp_disconnect(protocol_data_t *protocol)
{
if (protocol == NULL || protocol->protocol_data == NULL) {
return;
}
sftp_data_t *data = (sftp_data_t *)protocol->protocol_data;
libssh2_sftp_shutdown(data->sftp_session);
libssh2_session_disconnect(data->session, "Normal Shutdown");
libssh2_session_free(data->session);
close(data->sock);
}
void SSH2Utils::deconnect() {
libssh2_session_disconnect(m_session,
"Normal Shutdown, Thank you for playing");
libssh2_session_free(m_session);
#ifdef WIN32
closesocket(m_sock);
#else
close(m_sock);
#endif
libssh2_exit();
m_session = 0;
m_sock = 0;
}
/*
* Cleanup data structures.
*/
static void cleanup(int code)
{
int ret;
char buf[1024];
if (ssh_info) {
close(ssh_info->forward_sock);
close(ssh_info->listen_sock);
if (ssh_info->channel) {
libssh2_channel_free(ssh_info->channel);
}
if (ssh_info->session) {
libssh2_session_disconnect(ssh_info->session,
"Client disconnecting normally");
libssh2_session_free(ssh_info->session);
}
free(ssh_info);
}
if (opt_dnat) {
/* Remove DNAT rule */
snprintf(buf, sizeof(buf), IPTABLE_DEL_DNAT, local_ip, local_port);
ret = system(buf);
if (ret != 0) {
DBG("DNAT iptables command failed\n%s", buf);
} else {
DBG("UDP traffic on port 53 restored");
}
}
if (opt_netfilter != -1) {
snprintf(buf, sizeof(buf), IPTABLE_DEL_QUEUE,
local_port, opt_netfilter);
ret = system(buf);
if (ret != 0) {
DBG("NFQUEUE iptables command failed\n%s", buf);
} else {
DBG("Queuing UDP traffic on port 53 removed on queue num %d",
opt_netfilter);
}
}
/* Always last */
if (code < 0) {
exit(EXIT_FAILURE);
} else {
exit(EXIT_SUCCESS);
}
}
void guac_common_ssh_destroy_session(guac_common_ssh_session* session) {
/* Disconnect and clean up libssh2 */
libssh2_session_disconnect(session->session, "Bye");
libssh2_session_free(session->session);
/* Destroy associated user */
if (session->user)
guac_common_ssh_destroy_user(session->user);
/* Free all other data */
free(session);
}
void stop_session_fixture()
{
if(connected_session) {
libssh2_session_disconnect(connected_session, "test ended");
libssh2_session_free(connected_session);
shutdown(connected_socket, 2);
connected_session = NULL;
}
else {
fprintf(stderr, "Cannot stop session - none started");
}
stop_openssh_fixture();
}
bool SSHSession::end_session(){
libssh2_session_disconnect(this->session, "Normal Shutdown, Thank you for playing");
libssh2_session_free(session);
#ifdef WIN32
closesocket(this->sock);
#else
::close(this->sock);
#endif
return true;
}
void CLibssh2::cleanup()
{
if (_session != NULL)
{
LIBSSH2_SESSION* session = static_cast<LIBSSH2_SESSION*>(_session);
libssh2_session_disconnect(session, "normal Shutdown");
libssh2_session_free(session);
_session = NULL;
}
if (_socket_fd != -1)
{
close(_socket_fd);
_socket_fd = -1;
}
}
PJSSH::~PJSSH()
{
if( SessionIsOk )
{
libssh2_session_disconnect(mSession,"Goodbye from PJSSH.");
libssh2_session_free(mSession);
}
#ifdef PJSSH_WINDOWS
closesocket(hSock);
WSACleanup();
#else
#ifdef PJSSH_POSIX
close(hSock);
#endif
#endif
}
int ssh::quit()
{
libssh2_session_disconnect(session,
"Normal Shutdown, Thank you for playing");
libssh2_session_free(session);
close(_sock_fd);
//cout << "all done" << std::endl;
libssh2_exit();
return 0;
}
/**
* @function SFTP.close
*
* ### Synopsis
*
* SFTP.close(handle);
*
* Close an SFTP connection and free up any resources used.
*
* @param {object} handle - handle to open connect returned by SFTP.connect().
*/
JSVAL sftp_close (JSARGS args) {
HandleScope scope;
SFTP *handle = HANDLE(args[0]);
if (handle->sftp_session) {
libssh2_sftp_shutdown(handle->sftp_session);
}
if (handle->session) {
libssh2_session_disconnect(handle->session, "SilkJS SFTP Disconnecting");
libssh2_session_free(handle->session);
}
if (handle->sock > 0) {
close(handle->sock);
}
delete handle;
return Undefined();
}
void CSSHTunnelThread::Cleanup()
{
// Close all the sockets
g_SSHThreadMutex.Lock();
subThreadSDSet::iterator it;
for( it = g_setSocketDescriptor.begin(); it != g_setSocketDescriptor.end(); ++it )
{
int socketDescriptor = *it;
#ifdef WIN32
closesocket(socketDescriptor);
#else
close(socketDescriptor);
#endif
}
g_SSHThreadMutex.Unlock();
Sleep(1000);
if(m_session)
{
libssh2_session_disconnect(m_session, "Client disconnecting normally");
libssh2_session_free(m_session);
m_session = NULL;
}
if (m_listensock)
{
#ifdef WIN32
closesocket(m_listensock);
#else
close(m_listensock);
#endif
m_listensock = 0;
}
if (m_sock)
{
#ifdef WIN32
closesocket(m_sock);
#else
close(m_sock);
#endif
m_sock = 0;
}
libssh2_exit();
}
int ssh_guac_client_free_handler(guac_client* client) {
ssh_guac_client_data* guac_client_data = (ssh_guac_client_data*) client->data;
/* Close SSH channel */
if (guac_client_data->term_channel != NULL) {
libssh2_channel_send_eof(guac_client_data->term_channel);
libssh2_channel_close(guac_client_data->term_channel);
}
/* Free terminal */
guac_terminal_free(guac_client_data->term);
pthread_join(guac_client_data->client_thread, NULL);
/* Free channels */
libssh2_channel_free(guac_client_data->term_channel);
/* Clean up SFTP */
if (guac_client_data->sftp_session)
libssh2_sftp_shutdown(guac_client_data->sftp_session);
if (guac_client_data->sftp_ssh_session) {
libssh2_session_disconnect(guac_client_data->sftp_ssh_session, "Bye");
libssh2_session_free(guac_client_data->sftp_ssh_session);
}
/* Free session */
if (guac_client_data->session != NULL)
libssh2_session_free(guac_client_data->session);
/* Free auth key */
if (guac_client_data->key != NULL)
ssh_key_free(guac_client_data->key);
/* Free clipboard */
guac_common_clipboard_free(guac_client_data->clipboard);
/* Free cursors */
guac_ssh_cursor_free(client, guac_client_data->ibar_cursor);
guac_ssh_cursor_free(client, guac_client_data->blank_cursor);
/* Free generic data struct */
free(client->data);
return 0;
}
int ssh_free(SSH * pSsh)
{
if (NULL==pSsh)
{
return 0;
}
pSsh->channel=NULL;
libssh2_session_disconnect(pSsh->session,"Normal Shutdown, Thank you for playing");
libssh2_session_free(pSsh->session);
close(pSsh->sock_fd);
fprintf(stderr, "all done\n");
libssh2_exit();
return 1;
}
/*
* Decrements the reference counter on the ruby session container.
* When this goes to 0 then the session will be released.
* */
void
libssh2_ruby_session_release(LibSSH2_Ruby_Session *session_data) {
// Decrease the reference count
session_data->refcount--;
// If the reference count is 0, free all the things!
if (session_data->refcount == 0) {
if (session_data->session != NULL) {
BLOCK(libssh2_session_disconnect(
session_data->session,
"Normal shutdown by libssh2-ruby."));
BLOCK(libssh2_session_free(session_data->session));
}
free(session_data);
}
}