static int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
{
struct timeval timeout;
int rc;
fd_set fd;
fd_set *writefd = NULL;
fd_set *readfd = NULL;
int dir;
timeout.tv_sec = 10;
timeout.tv_usec = 0;
FD_ZERO(&fd);
FD_SET(socket_fd, &fd);
/* now make sure we wait in the correct direction */
dir = libssh2_session_block_directions(session);
if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
readfd = &fd;
if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
writefd = &fd;
rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
return rc;
}
RET_CODE StartLineProcessCollector::waitsocket(int socket_fd, LIBSSH2_SESSION *session) {
struct timeval timeout;
int rc;
fd_set fd;
fd_set *writefd = NULL;
fd_set *readfd = NULL;
int dir;
timeout.tv_sec = 10;
timeout.tv_usec = 0;
FD_ZERO(&fd);
FD_SET(socket_fd, &fd);
dir = libssh2_session_block_directions(session);
if (dir & LIBSSH2_SESSION_BLOCK_INBOUND)
readfd = &fd;
if (dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
writefd = &fd;
rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
return rc;
}
static int waitsocket(int socket_fd, LIBSSH2_SESSION* ssh_session, time_t timeout_sec)
{
int ec;
struct timeval timeout;
fd_set fd;
fd_set* writefd = NULL;
fd_set* readfd = NULL;
int dir;
timeout.tv_sec = timeout_sec;
timeout.tv_usec = 0;
FD_ZERO(&fd);
FD_SET(socket_fd, &fd);
dir = libssh2_session_block_directions(ssh_session);
if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
{
readfd = &fd;
}
if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
{
writefd = &fd;
}
ec = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
return ec;
}
/* A non-blocking call returned EAGAIN, so yield, ensuring the
* handlers are set up so that we'll be rescheduled when there is an
* interesting event on the socket.
*/
static coroutine_fn void co_yield(BDRVSSHState *s, BlockDriverState *bs)
{
int r;
IOHandler *rd_handler = NULL, *wr_handler = NULL;
Coroutine *co = qemu_coroutine_self();
r = libssh2_session_block_directions(s->session);
if (r & LIBSSH2_SESSION_BLOCK_INBOUND) {
rd_handler = restart_coroutine;
}
if (r & LIBSSH2_SESSION_BLOCK_OUTBOUND) {
wr_handler = restart_coroutine;
}
DPRINTF("s->sock=%d rd_handler=%p wr_handler=%p", s->sock,
rd_handler, wr_handler);
aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock,
false, rd_handler, wr_handler, NULL, co);
qemu_coroutine_yield();
DPRINTF("s->sock=%d - back", s->sock);
aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock, false,
NULL, NULL, NULL, NULL);
}
int
sftpfs_waitsocket (sftpfs_super_data_t * super_data, GError ** mcerror)
{
struct timeval timeout = { 10, 0 };
fd_set fd;
fd_set *writefd = NULL;
fd_set *readfd = NULL;
int dir;
mc_return_val_if_error (mcerror, -1);
FD_ZERO (&fd);
FD_SET (super_data->socket_handle, &fd);
/* now make sure we wait in the correct direction */
dir = libssh2_session_block_directions (super_data->session);
if ((dir & LIBSSH2_SESSION_BLOCK_INBOUND) != 0)
readfd = &fd;
if ((dir & LIBSSH2_SESSION_BLOCK_OUTBOUND) != 0)
writefd = &fd;
return select (super_data->socket_handle + 1, readfd, writefd, NULL, &timeout);
}
@return block directions\n\
@rtype int";
static PyObject *
PYLIBSSH2_Session_blockdirections(PYLIBSSH2_SESSION *self, PyObject *args)
{
int blockedon;
blockedon = libssh2_session_block_directions(self->session);
return Py_BuildValue("i", blockedon);
}
// http://www.libssh2.org/examples/ssh2_exec.html
bool CLibssh2::timedwait_socket()
{
int events_requested = 0;
LIBSSH2_SESSION* session = static_cast<LIBSSH2_SESSION*>(_session);
// now make sure we wait in the correct direction
int direction = libssh2_session_block_directions(session);
if(direction & LIBSSH2_SESSION_BLOCK_INBOUND)
events_requested |= POLLIN;
if(direction & LIBSSH2_SESSION_BLOCK_OUTBOUND)
events_requested |= POLLOUT;
return CUtils::timed_poll(_socket_fd, events_requested, _timeout_seconds*1000);
}
static int uwsgi_ssh_waitsocket(int socket_fd, LIBSSH2_SESSION *session) {
int dir = libssh2_session_block_directions(session);
if (dir & LIBSSH2_SESSION_BLOCK_INBOUND) {
if (uwsgi.wait_read_hook(socket_fd, ulibssh2.ssh_timeout) < 0) {
uwsgi_error("uwsgi_ssh_waitsocket()/wait_read_hook()");
return -1;
}
}
if (dir & LIBSSH2_SESSION_BLOCK_OUTBOUND) {
if (uwsgi.wait_write_hook(socket_fd, ulibssh2.ssh_timeout) < 0) {
uwsgi_error("uwsgi_ssh_waitsocket()/wait_write_hook()");
return -1;
}
}
return 0;
}
static coroutine_fn void set_fd_handler(BDRVSSHState *s)
{
int r;
IOHandler *rd_handler = NULL, *wr_handler = NULL;
Coroutine *co = qemu_coroutine_self();
r = libssh2_session_block_directions(s->session);
if (r & LIBSSH2_SESSION_BLOCK_INBOUND) {
rd_handler = restart_coroutine;
}
if (r & LIBSSH2_SESSION_BLOCK_OUTBOUND) {
wr_handler = restart_coroutine;
}
DPRINTF("s->sock=%d rd_handler=%p wr_handler=%p", s->sock,
rd_handler, wr_handler);
qemu_aio_set_fd_handler(s->sock, rd_handler, wr_handler, return_true, co);
}
void FSSftp::WaitSocket( FSCInfo* info ) //throw int(errno) or int(-2) on stop
{
while ( true )
{
if ( info && info->Stopped() ) { throw int( -2 ); } //stopped
int dir = libssh2_session_block_directions( sshSession );
if ( ( dir & ( LIBSSH2_SESSION_BLOCK_INBOUND | LIBSSH2_SESSION_BLOCK_OUTBOUND ) ) == 0 )
{
return ;
}
int n = _sock.Select2(
( dir & LIBSSH2_SESSION_BLOCK_INBOUND ) != 0,
( dir & LIBSSH2_SESSION_BLOCK_OUTBOUND ) != 0,
3 );
if ( n > 0 ) { return; }
}
}
int waitsocket(LIBSSH2_SESSION *session, int sock)
{
struct timeval timeout;
int rc;
fd_set fd;
fd_set *writefd = NULL;
fd_set *readfd = NULL;
int dir;
timeout.tv_sec = 1;
timeout.tv_usec = 0;
FD_ZERO(&fd);
FD_SET(sock, &fd);
dir = libssh2_session_block_directions(session);
if (dir & LIBSSH2_SESSION_BLOCK_INBOUND)
readfd = &fd;
if (dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
writefd = &fd;
rc = select(sock+1, readfd, writefd, NULL, &timeout);
return rc;
}
/*
* call-seq:
* session.block_directions
*
* Returns an int that determines the direction to wait on the socket
* in the case of an EAGAIN. This will be a binary mask that can be
* checked with `Native::SESSION_BLOCK_INBOUND` and
* `Native::SESSION_BLOCK_OUTBOUND`.
* */
static VALUE
block_directions(VALUE self) {
return INT2FIX(libssh2_session_block_directions(get_session(self)));
}
