Retro68/LaunchAPPL/SSH.cc

#include "SSH.h"
#include "Launcher.h"
#include "Utilities.h"

#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <signal.h>
#include <boost/lexical_cast.hpp>

namespace po = boost::program_options;
using std::string;
using std::vector;

class SSHLauncher : public Launcher
{
public:
	SSHLauncher(po::variables_map& options);
	virtual ~SSHLauncher();

	virtual bool Go(int timeout = 0);

};

SSHLauncher::SSHLauncher(po::variables_map &options)
    : Launcher(options, ResourceFile::Format::percent_appledouble)
{

}

SSHLauncher::~SSHLauncher()
{

}

static void insertArgs(vector<string>& args, po::variables_map& options, string name)
{
	if(options.count(name))
	{
		auto extraArgs = SplitArguments(options[name].as<vector<string>>());
		args.insert(args.end(), extraArgs.begin(), extraArgs.end());
	}
}

bool SSHLauncher::Go(int timeout)
{
	std::vector<std::string> args;
	args.push_back(options["ssh-host"].as<string>());
	insertArgs(args, options, "ssh-args");
	args.push_back("--");
	args.push_back(options["ssh-remote-path"].as<string>());
	insertArgs(args, options, "ssh-remote-args");
	if(timeout)
	{
		args.push_back("--timeout");
		args.push_back(boost::lexical_cast<std::string>(timeout));
	}
	args.push_back("-");

	std::string program = options["ssh-path"].as<std::string>();

	std::vector<const char*> argv;
	argv.push_back(program.c_str());
	for(std::string& s : args)
		argv.push_back(s.c_str());
	argv.push_back(NULL);

	int fd[2];
	pipe(fd);
	const int READ_END = 0;
	const int WRITE_END = 1;

	pid_t pid = fork();
	if(pid < 0)
	{
		perror("unable to fork");
		return 1;
	}
	else if(pid == 0)
	{
		dup2(fd[READ_END], STDIN_FILENO);
		close(fd[WRITE_END]);
		close(fd[READ_END]);

		execvp(argv[0], const_cast<char* const *> (argv.data()));
		perror("exec failed");
		std::cerr << "Tried to execute: " << program;
		for(auto a : args)
			std::cerr << " " << a;
		std::cerr << std::endl;
		_exit(1);
	}
	else
	{
		close(fd[READ_END]);

		std::ostringstream tmp;
		app.write(tmp, ResourceFile::Format::macbin);
		const std::string data = tmp.str();

		write(fd[WRITE_END], data.data(), data.size());
		close(fd[WRITE_END]);

		int wstatus;
		int result = 0;
		do
		{
			result = waitpid(pid, &wstatus, 0);
		} while(result == -1 && errno == EINTR);

		if(!WIFEXITED(wstatus))
		{
			return false;
		}
		else
		{
			//int exitcode = WEXITSTATUS(wstatus);
			return true;
		}
	}
}



void SSH::GetOptions(options_description &desc)
{
	desc.add_options()
	        ("ssh-path", po::value<string>()->default_value("ssh"),"ssh command to use")
	        ("ssh-host", po::value<string>(),
	            "[username@]address of remote host")
	        ("ssh-args", po::value<vector<string>>(),
	            "additional arguments for ssh")
	        ("ssh-remote-path", po::value<string>()->default_value("LaunchAPPL"),
	            "path to LaunchAPPL on remote host")
	        ("ssh-remote-args", po::value<vector<string>>(),
	            "additional arguments for LaunchAPPL on remote host")
	        ;

}

bool SSH::CheckOptions(variables_map &options)
{
	return options.count("ssh-host") != 0;
}

std::unique_ptr<Launcher> SSH::MakeLauncher(variables_map &options)
{
	return std::unique_ptr<Launcher>(new SSHLauncher(options));
}