void * sendm(void * ptr)
{
channel_set chset;
int err, nb = 0;
msg_t tmp;
tmp.pid = getpid();
sprintf(tmp.content," %ld @ %d !\n",pthread_self(),tmp.pid);
chset.chan = chan_s;
chset.events = CHANNEL_EVENT_WRITE|CHANNEL_EVENT_CLOSE;
chset.revents = CHANNEL_EVENT_NOEVT;
while(nb < MAX_MSG)
{
chset.revents = CHANNEL_EVENT_NOEVT;
err = channel_select(&chset,1,CHANNEL_TIME_WAIT);
if(err == -1)
{
perror("channel_select()");
}
else if(err == 0)
continue;
if(CHAN_WRITE_EVT(chset.revents))
{
err = channel_send(chan_s,&tmp);
if(err == -1)
{
if(errno == EWOULDBLOCK)
continue;
perror("sendm channel_send()");
channel_close(chan_s);
break;
}
nb++;
}
if(CHAN_CLOSE_EVT(chset.revents))
break;
}
pthread_exit(NULL);
}
static gboolean remmina_nx_session_get_response(RemminaNXSession *nx)
{
struct timeval timeout;
ssh_channel ch[2];
ssh_buffer buffer;
gint len;
gint is_stderr;
timeout.tv_sec = 60;
timeout.tv_usec = 0;
ch[0] = nx->channel;
ch[1] = NULL;
channel_select(ch, NULL, NULL, &timeout);
is_stderr = 0;
while (is_stderr <= 1)
{
len = channel_poll(nx->channel, is_stderr);
if (len == SSH_ERROR)
{
remmina_nx_session_set_error(nx, "Error reading channel: %s");
return FALSE;
}
if (len > 0)
break;
is_stderr++;
}
if (is_stderr > 1)
return FALSE;
buffer = buffer_new();
len = channel_read_buffer(nx->channel, buffer, len, is_stderr);
if (len <= 0)
{
remmina_nx_session_set_application_error(nx, "Channel closed.");
return FALSE;
}
if (len > 0)
{
g_string_append_len(nx->response, (const gchar*) buffer_get(buffer), len);
}
buffer_free(buffer);
return TRUE;
}
void * receive(void * ptr)
{
int err;
msg_t tmp;
channel_set chset;
chset.chan = chan_r;
chset.events = CHANNEL_EVENT_READ|CHANNEL_EVENT_CLOSE;
while(1)
{
chset.revents = CHANNEL_EVENT_NOEVT;
err = channel_select(&chset,1,-1);
if(err == -1)
{
perror("recv - channel_select()");
channel_close(chan_s);
channel_close(chan_r);
break;
}
else if(err == 0)
continue;
if(CHAN_READ_EVT(chset.revents))
{
err = channel_recv(chan_r,&tmp);
if(err <= 0)
{
break;
}
/*else if(err > 0)
printf("%s",tmp.content);*/
}
else if(CHAN_CLOSE_EVT(chset.revents))
{
channel_close(chan_r);
break;
}
}
pthread_exit(NULL);
}
void select_loop(SSH_SESSION *session,CHANNEL *channel){
fd_set fds;
struct timeval timeout;
char buffer[10];
BUFFER *readbuf=buffer_new();
CHANNEL *channels[2];
int lus;
int eof=0;
int maxfd;
int ret;
while(channel){
/* when a signal is caught, ssh_select will return
* with SSH_EINTR, which means it should be started
* again. It lets you handle the signal the faster you
* can, like in this window changed example. Of course, if
* your signal handler doesn't call libssh at all, you're
* free to handle signals directly in sighandler.
*/
do{
FD_ZERO(&fds);
if(!eof)
FD_SET(0,&fds);
timeout.tv_sec=30;
timeout.tv_usec=0;
FD_SET(ssh_get_fd(session),&fds);
maxfd=ssh_get_fd(session)+1;
ret=select(maxfd,&fds,NULL,NULL,&timeout);
if(ret==EINTR)
continue;
if(FD_ISSET(0,&fds)){
lus=read(0,buffer,10);
if(lus)
channel_write(channel,buffer,lus);
else {
eof=1;
channel_send_eof(channel);
}
}
if(FD_ISSET(ssh_get_fd(session),&fds)){
ssh_set_fd_toread(session);
}
channels[0]=channel; // set the first channel we want to read from
channels[1]=NULL;
ret=channel_select(channels,NULL,NULL,NULL); // no specific timeout - just poll
if(signal_delayed)
sizechanged();
} while (ret==EINTR || ret==SSH_EINTR);
// we already looked for input from stdin. Now, we are looking for input from the channel
if(channel && channel_is_closed(channel)){
channel_free(channel);
channel=NULL;
channels[0]=NULL;
}
if(channels[0]){
while(channel && channel_is_open(channel) && channel_poll(channel,0)){
lus=channel_read(channel,readbuf,0,0);
if(lus==-1){
ssh_say(0,"error reading channel : %s\n",ssh_get_error(session));
return;
}
if(lus==0){
ssh_say(1,"EOF received\n");
channel_free(channel);
channel=channels[0]=NULL;
} else
write(1,buffer_get(readbuf),lus);
}
while(channel && channel_is_open(channel) && channel_poll(channel,1)){ /* stderr */
lus=channel_read(channel,readbuf,0,1);
if(lus==-1){
ssh_say(0,"error reading channel : %s\n",ssh_get_error(session));
return;
}
if(lus==0){
ssh_say(1,"EOF received\n");
channel_free(channel);
channel=channels[0]=NULL;
} else
write(2,buffer_get(readbuf),lus);
}
}
if(channel && channel_is_closed(channel)){
channel_free(channel);
channel=NULL;
}
}
buffer_free(readbuf);
}
void * forward(void * ptr)
{
int err;
msg_t tmp;
channel_set s_chset, r_chset;
s_chset.chan = chan_s;
s_chset.events = CHANNEL_EVENT_READ|CHANNEL_EVENT_CLOSE;
r_chset.chan = chan_r;
r_chset.events = CHANNEL_EVENT_WRITE|CHANNEL_EVENT_CLOSE;
while(n < MAX_FWD_MSG)
{
s_chset.revents = CHANNEL_EVENT_NOEVT;
r_chset.revents = CHANNEL_EVENT_NOEVT;
err = channel_select(&s_chset,1,CHANNEL_TIME_WAIT);
if(err == -1)
{
perror("FWD - 1 channel_select()");
channel_close(chan_s);
channel_close(chan_r);
break;
}
else if(err == 0)
continue;
if(CHAN_READ_EVT(s_chset.revents))
{
err = channel_recv(chan_s,&tmp);
if(err == -1)
{
perror("FWD - error channel_recv");
channel_close(chan_s);
channel_close(chan_r);
break;
}
}
else if(CHAN_CLOSE_EVT(s_chset.revents))
{
channel_close(chan_r);
break;
}
err = channel_select(&r_chset,1,CHANNEL_TIME_WAIT);
if(err == -1)
{
perror("FWD - 1 channel_select()");
channel_close(chan_s);
channel_close(chan_r);
break;
}
else if(err == 0)
continue;
if(CHAN_WRITE_EVT(r_chset.revents))
{
err = channel_send(chan_r,&tmp);
if(err == -1)
{
perror("FWD - error channel_send");
channel_close(chan_s);
channel_close(chan_r);
break;
}
n += 1;
if(n >= MAX_FWD_MSG)
{
//printf("n : %d OK \n",n);
channel_close(chan_s);
channel_close(chan_r);
}
}
else if(CHAN_CLOSE_EVT(r_chset.revents))
{
channel_close(chan_s);
break;
}
}
pthread_exit(NULL);
}
