GlobalParameters() {
parse_options("benchmark.json", mem_allowed, genome_len, scores_to_test, p_values_to_test, matrix_filename, p_value);
std::cout << hayai::Console::TextGreen << "[Testing parameters: ]" << hayai::Console::TextDefault << std::endl;
std::cout << "\tMemory allowed to use: " << mem_allowed << " bytes" << std::endl;
Pwm matrix(matrix_filename, p_value);
patterns_allowed = ( mem_allowed - READ_BLOCK_SIZE) / (32*(matrix.getLength()));
std::cout << "\tThis means that we will process maximum " << patterns_allowed << " patterns in each point of time." << std::endl;
std::cout << "\tModel is: " << matrix_filename << std::endl;
std::cout << "\tSelected p_value: " << p_value << std::endl;
size_t len = check_file_exists(get_working_path() + std::string("-chr_random.plain"));
if (len == 0) {
std::cout << "\tTest genome missing; generating random genome with length: " << genome_len << std::endl;
std::string chromofile = get_working_path() + std::string("-chr_random.plain");
std::ofstream chromo(chromofile.c_str());
static const char alphabet[] = "ACGT";
for (size_t i=0; i < genome_len; i++) {
chromo << alphabet[rand() % (sizeof(alphabet)-1)];
}
chromo.close();
} else {
std::cout << "\tTest genome is present; it's length equals " << len << std::endl;
genome_len = len;
}
if (scores_to_test > genome_len) scores_to_test = genome_len - 100;
std::cout << hayai::Console::TextGreen << "[Parameters for benchmark initialized successfully]" << hayai::Console::TextDefault << std::endl;
}
virtual void SetUp() {
this->matrix = new Pwm(global_params.matrix_filename, global_params.p_value);
std::vector<string> filenames, chromonames;
std::vector<size_t> starts, ends;
filenames.push_back(get_working_path() + std::string("-chr_random.plain"));
chromonames.push_back(std::string("bench_chromo"));
starts.push_back(0);
ends.push_back(global_params.genome_len-1);
sequences = new ChromoVector(filenames, chromonames, starts, ends, this->matrix->getLength());
for (size_t i = 0; i < global_params.scores_to_test - this->matrix->getLength() -1 ; i++) {
stream << i << std::endl;
}
size_t buf = 0;
for (int k = 0; k < global_params.mem_allowed / 8 && stream >> buf; k++) {
this->positions_to_read_again.push_back(buf);
}
if (positions_to_read_again.empty()) {
std::cout << "ERROR!" << std::endl;
}
words_as_paths.resize(global_params.scores_to_test - this->matrix->getLength());
this->sequences->getWordsAsPaths(0, positions_to_read_again, this->matrix->getLength(), words_as_paths);
}
void FontManager::addFont(const std::string& _filename, const std::string& _fontName) {
if (m_Fonts.find(_fontName) == m_Fonts.end()) {
auto t = new sf::Font();
if (!t->loadFromFile(_filename)) {
auto cwd = get_working_path();
throw std::runtime_error("Failed to load font");
}
m_Fonts.insert(std::pair<std::string, sf::Font *>(_fontName, t));
}
}
virtual void SetUp() {
this->matrix = new Pwm(global_params.matrix_filename, global_params.p_value);
this->atm = new AhoCorasickPlus();
init_ahoc(*(this->atm), *(this->matrix), global_params.patterns_allowed, total_words);
atm->finalize();
std::vector<string> filenames, chromonames;
std::vector<size_t> starts, ends;
filenames.push_back(get_working_path() + std::string("-chr_random.plain"));
chromonames.push_back(std::string("bench_chromo"));
starts.push_back(0);
ends.push_back(global_params.genome_len-1);
sequences = new ChromoVector(filenames, chromonames, starts, ends, this->matrix->getLength());
total_words=0;
files_to_merge = new std::vector<std::vector<std::string> >;
}
/**
* Main Program
*/
int main(int argc, char **argv)
{
TelnetDaemon daemon;
std::string loginpath;
std::string user;
std::string login;
std::string cdw = get_working_path();
int num = 0;
for (int i = 0; ; i++)
{
if (cdw[i] == '\0') break;
if (cdw[i] == '/') num = i;
}
if (num != 0)
{
for (int i = 0; i < num+1; i++)
{
PATH[i] = cdw[i];
}
}
else
{
strcpy(PATH,cdw.c_str());
}
// If Config Exists Run
if (configdataexists())
{
parseconfig();
}
// Unique filename to pass to BBS for
// Reading in Detected Client Terminal.
daemon.make_uuid(ENTHRAL_TEMP_PATH);
// Lookup info for the passed socket descriptor
daemon.get_host_info();
// Parameter for Login Program and User Login ID.
int c = '\0';
for (;;)
{
c = getopt( argc, argv, "l:u:");
if (c == EOF) break;
switch (c)
{
case 'u':
user = strdup(optarg);
break;
case 'l':
login = strdup(optarg);
break;
default:
printf("%c\n", c);
show_usage();
exit(1);
}
}
if(login.size() > 0)
{
loginpath = login;
login.erase();
}
else
{
loginpath = "/bin/login";
}
argv_init[0] = strdup(loginpath.c_str());
argv_init[1] = (char *)daemon.m_hostaddr_string.c_str();
argv_init[2] = (char *)daemon.m_hostname_string.c_str();
// Pass Login user for External Process
if(user.size() > 0)
{
argv_init[3] = strdup("-f");
argv_init[4] = strdup(user.c_str());
}
// Filename for passing the TERM to the external program.
if(daemon.m_term_passing.size() > 0)
{
argv_init[5] = strdup(daemon.m_term_passing.c_str());
}
// Startup Syslogd.
openlog("telnet_daemon", LOG_PID, LOG_SYSLOG);
syslog(LOG_INFO, "telnet_daemon in.telnetd PATH: %s", PATH);
daemon.errlog((char *)"telnet_daemon in.telnetd PATH: %s", PATH);
// Log Connection
syslog(LOG_INFO, "telnet_daemon in.telnetd [%s] [Server Path]", loginpath.c_str());
daemon.errlog((char *)"telnet_daemon in.telnetd [%s] [Server Path]", (char *)loginpath.c_str());
syslog(LOG_INFO, "telnet_daemon in.telnetd [IP %s] [Host %s] [Connection Logged]",
daemon.m_hostaddr_string.c_str(),
daemon.m_hostname_string.c_str()
);
daemon.errlog((char *)"telnet_daemon in.telnetd [IP %s] [Host %s] [Connection Logged]",
(char *)daemon.m_hostaddr_string.c_str(),
(char *)daemon.m_hostname_string.c_str()
);
// Send Startup Telnet Sequences to connecting client.
// Ready for Terminal / NAWS Detection and setting defaults.
daemon.errlog((char *)"send_startup_iac");
daemon.send_startup_iac();
// Look intitial TELOPT codes with (2) second pause then (2) second detection loop
// To Catch Terminal Type and NAWS.
daemon.errlog((char *)"loop_detection");
daemon.loop_detection();
daemon.errlog((char *)"loop_detection completed.");
// Display Detected Term, Rows, Cols.
daemon.errlog((char *)"Term Type: %s", (char *)daemon.getTermType().c_str());
daemon.errlog((char *)"Term Cols: %i", daemon.getTermCols());
daemon.errlog((char *)"Term Rows: %i", daemon.getTermRows());
if (daemon.getTermType() == "undetected" || daemon.getTermType() == "VT220" || daemon.getTermType() == "")
{
daemon.errlog((char *)"No Term Detected, Disconnecting.");
closelog();
exit(1);
}
// Terminal Type Detection completed, write out to file for extrnal program
// So the Forked process can read it in.
std::ofstream out;
out.open(daemon.m_term_passing.c_str(),ios::trunc);
if (out.is_open())
{
out << daemon.getTermType() << endl;
out.close();
}
daemon.errlog((char *)"Starting BBS Server forkpty()");
// If the Connection is good, fork and start the BBS
pid = forkpty(&ptyfd, NULL, NULL, NULL);
daemon.errlog((char *)"ptyfd: %i", ptyfd);
// Pid 0 Start Child Process.
if (pid == 0)
{
setsid();
tcsetpgrp(0, getpid());
// exec shell, with correct argv and env
execv(loginpath.c_str(), argv_init);
syslog(LOG_INFO, "child process created for [IP %s] pid == 0", daemon.m_hostaddr_string.c_str());
daemon.errlog((char *)"child process created for [IP %s] pid == 0", (char*)daemon.m_hostaddr_string.c_str());
exit(1);
}
// Pid -1 is an error
else if(pid == -1)
{
syslog(LOG_INFO, "fork() Error, exiting [IP %s] pid == -1", daemon.m_hostaddr_string.c_str());
daemon.errlog((char *)"fork() Error, exiting [IP %s] pid == -1", (char*)daemon.m_hostaddr_string.c_str());
closelog();
exit(1);
}
else if(pid > 0)
{
// Parent process.
syslog(LOG_INFO, "parent process for [IP %s] pid > 0", daemon.m_hostaddr_string.c_str());
daemon.errlog((char *)"parent process for [IP %s] pid > 0", (char*)daemon.m_hostaddr_string.c_str());
}
// Setup Detected Screen Size.
struct winsize ws;
// setup Term
init_termbuf();
#ifdef TIOCSWINSZ
if (daemon.getTermCols() || daemon.getTermRows())
{
memset(&ws, 0, sizeof(ws));
ws.ws_col = daemon.getTermCols();
ws.ws_row = daemon.getTermRows();
ioctl(ptyfd, TIOCSWINSZ, (char *)&ws);
}
#endif
// Start Main Parent Loop for communication with child (BBS)
daemon.errlog((char *)"Starting Parent Loop");
daemon.loop_parent_process(ptyfd);
daemon.errlog((char *)"Closing Parent Loop");
raise(SIGHUP);
syslog(LOG_INFO, "in.telnetd [IP %s] [Closed Connection]", daemon.m_hostaddr_string.c_str());
daemon.errlog((char *)"in.telnetd [IP %s] [Closed Connection]", (char*)daemon.m_hostaddr_string.c_str());
closelog();
remove(daemon.m_term_passing.c_str());
_exit(0);
}
DataHandler::resource DataHandler::read_resource(std::string path, std::string cookies, DataHandler::resource * data) {
// prepend cwd() to path
if (!verify_path(path))
path = "/index.html";
std::string cwd = get_working_path();
path = cwd + path;
this->logger->debug("Checking resource at: " + path);
// first check if such a file even exists
int fd = open(path.c_str(), O_RDONLY);
if (fd < 0) {
char * err = std::strerror(errno);
throw DataHandler::FileNotFound("Error while reading file contents at " + path + ": " + std::string(err ? err : "unknown error"));
}
close(fd);
// check mime type of resource
DataHandler::Exec runner;
std::string args[2] = { "/usr/bin/file", path };
DataHandler::resource file_mime = runner.run_command(args);
char * mime = file_mime.data;
std::string ext = path.substr(path.length()-3);
for(char c : ext)
c = std::toupper(c);
DataHandler::resource output;
// now check for known mime types
if (is(mime, "executable")) {
// run the script, pass the data
std::string args[2] = { path, "" }; // TODO: Fix me too!
DataHandler::resource script_output = runner.run_command(args, data, cookies);
output.data = script_output.data;
output.size = script_output.size;
output.type = "executable";
}
// TODO: Move this definition to some more reasonable place
else if (is(mime, "HTML")) { output.type = "text/html; charset=UTF-8"; }
else if (is(mime, "ASCII") && ext == "CSS") { output.type = "text/css"; }
else if (is(mime, "ERROR") || is(mime, "ASCII")) { output.type = "text/plain; charset=UTF-8"; }
else if (is(mime, "JPEG")) { output.type = "image/jpeg"; }
else if (is(mime, "PNG")) { output.type = "image/png"; }
else if (is(mime, "MS Windows icon")) { output.type = "image/vnd.microsoft.icon"; }
if (output.type.length() > 0 && output.type != "executable") {
DataHandler::Static getter;
DataHandler::resource f = getter.get_file(path);
output.data = f.data;
output.size = f.size;
}
else if (output.type.length() == 0){
std::string error_str = "Unsupported mime type: " + std::string(mime);
// drop 'local' part of path
size_t pos = 0;
while ((pos = error_str.find(cwd)) != std::string::npos )
error_str.erase(pos, cwd.length());
throw DataHandler::Unsupported(error_str);
}
return output;
}
