void Worker::test_connections(){
map<int, QMovie*> inv;
for(map<QMovie*, int>::iterator i = caller->myMovies.begin() ; i != caller->myMovies.end(); i++){
inv[i->second] = i->first;
}
char buffer[1024];
char *line_p;
string command;
FILE * fp;
for(map<int, QMovie*>::iterator i = inv.begin() ; i != inv.end(); i++){
command = "ssh -o ConnectTimeout=5 "+caller->ui->listWidget->item(i->first)->text().toStdString()+" hostname";
fp = popen(command.c_str(), "r");
if (!fp)
{
emit host_disconnected(i->second);
}
line_p = fgets(buffer, sizeof(buffer), fp);
if(line_p){
emit host_connected(i->second);
}
else{
emit host_disconnected(i->second);
}
pclose(fp);
}
}
reply(const char* format, ...)
{
if (!host_connected())
return 1;
va_list args, dbug_args;
va_start (args, format);
va_copy (dbug_args, args);
vdbug (1, format, dbug_args);
int ret = vfprintf (stapsh_out, format, args);
fflush (stapsh_out);
va_end (dbug_args);
va_end (args);
return ret;
}
int
main(int argc, char* const argv[])
{
// set those right away so that *print* statements don't fail
stapsh_in = stdin;
stapsh_out = stdout;
stapsh_err = stderr;
parse_args(argc, argv);
// we're gonna need this for setup_signals so let's do it now
if (uname(&uts))
die("Error calling uname");
setup_signals();
if (listening_port != NULL)
{
listening_port_fd = open(listening_port, O_RDWR);
if (listening_port_fd == -1)
// no one might be watching but might as well print
die("Error calling open()");
if (can_sigio())
{
// make ourselves the recipient of SIGIO signals for this port
if (fcntl(listening_port_fd, F_SETOWN, getpid()) < 0)
die("Error calling fcntl F_SETOWN");
// add O_ASYNC flag to enable SIGIO notifications on this port
int flags = fcntl(listening_port_fd, F_GETFL);
if (flags == -1)
die("Error calling fcntl F_GETFL");
if (fcntl(listening_port_fd, F_SETFL, flags | O_ASYNC) == -1)
die("Error calling fcntl F_SETFL");
}
// We need to have different FILE* for each direction, otherwise
// we'll have trouble down the line due to stdio's buffering
// (doing "r+" on sockets is very wonky)
stapsh_in = fdopen(listening_port_fd, "r");
stapsh_out = fdopen(listening_port_fd, "w");
stapsh_err = stapsh_out;
if (!stapsh_in || !stapsh_out)
die("Could not open serial port");
}
umask(0077);
snprintf(tmpdir, sizeof(tmpdir), "%s/stapsh.XXXXXX",
getenv("TMPDIR") ?: "/tmp");
if (!mkdtemp(tmpdir))
die ("Can't make a temporary working directory");
if (chdir(tmpdir))
die ("Can't change to temporary working directory \"%s\"", tmpdir);
// Prep pfds. For now we're only interested in commands from stap, and we
// don't poll staprun until it is started.
pfds[PFD_STAP_OUT].fd = fileno(stapsh_in);
pfds[PFD_STAP_OUT].events = POLLIN;
pfds[PFD_STAPRUN_OUT].events = 0;
pfds[PFD_STAPRUN_ERR].events = 0;
// Wait until a host connects before entering the command loop or poll() will
// return with POLLHUP right away. Note that sleep() will be interrupted upon
// SIGIO.
if (listening_port != NULL)
while (!host_connected())
sleep(2); // Once we support only platforms with guaranteed SIGIO support,
// we could replace this with a pause().
// keep polling as long as we're listening for stap commands
while (pfds[PFD_STAP_OUT].events)
{
if (poll(pfds, 3, -1) < 0)
{
if (errno == EINTR)
continue; // go back to poll()
else
die ("poll() failed with critical error");
}
if (pfds[PFD_STAP_OUT].revents & POLLHUP)
break;
if (pfds[PFD_STAP_OUT].revents & POLLIN)
process_command();
if (pfds[PFD_STAPRUN_OUT].revents & POLLIN)
prefix_staprun(PFD_STAPRUN_OUT, stapsh_out, "stdout");
if (pfds[PFD_STAPRUN_ERR].revents & POLLIN)
prefix_staprun(PFD_STAPRUN_ERR, stapsh_err, "stderr");
}
cleanup(0);
}
