From 7a0759d434d06305d7e602bd5debf9d01b92bbd1 Mon Sep 17 00:00:00 2001 From: Markus Grüneis Date: Thu, 4 Feb 2010 00:14:52 +0000 Subject: win32 support for sysExec, sysExec.hpp arch-specific files introduced --- src/posix/sysExec.hpp | 166 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/sysExec.cpp | 130 +++------------------------------------ src/sysExec.h | 11 +++- src/win32/sysExec.hpp | 160 ++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 342 insertions(+), 125 deletions(-) create mode 100644 src/posix/sysExec.hpp create mode 100644 src/win32/sysExec.hpp (limited to 'src') diff --git a/src/posix/sysExec.hpp b/src/posix/sysExec.hpp new file mode 100644 index 0000000..506e03d --- /dev/null +++ b/src/posix/sysExec.hpp @@ -0,0 +1,166 @@ +/* + * anytun + * + * The secure anycast tunneling protocol (satp) defines a protocol used + * for communication between any combination of unicast and anycast + * tunnel endpoints. It has less protocol overhead than IPSec in Tunnel + * mode and allows tunneling of every ETHER TYPE protocol (e.g. + * ethernet, ip, arp ...). satp directly includes cryptography and + * message authentication based on the methodes used by SRTP. It is + * intended to deliver a generic, scaleable and secure solution for + * tunneling and relaying of packets of any protocol. + * + * + * Copyright (C) 2007-2009 Othmar Gsenger, Erwin Nindl, + * Christian Pointner + * + * This file is part of Anytun. + * + * Anytun is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. + * + * Anytun is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with anytun. If not, see . + */ +#pragma once +#ifndef ANYTUN_sysexec_hpp_INCLUDED +#define ANYTUN_sysexec_hpp_INCLUDED + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +SysExec::~SysExec() +{ + if(!closed_) + close(pipefd_); +} + +char** dupEnv(StringList const& env) +{ + char** evp; + evp = new char*[env.size() + 1]; + unsigned int i = 0; + for(StringList::const_iterator it = env.begin(); it != env.end(); ++it) { + evp[i] = new char[it->size() + 1]; + std::strcpy(evp[i], it->c_str()); + ++i; + } + evp[env.size()] = NULL; + return evp; +} + +void SysExec::doExec(std::string const& script, StringVector const& args, StringList const& env) +{ + int pipefd[2]; + if(pipe(pipefd) == -1) { + cLog.msg(Log::PRIO_ERROR) << "executing script '" << script << "' pipe() error: " << AnytunErrno(errno); + return; + } + + pid_ = fork(); + if(pid_ == -1) { + cLog.msg(Log::PRIO_ERROR) << "executing script '" << script << "' fork() error: " << AnytunErrno(errno); + return; + } + + if(pid_) { + close(pipefd[1]); + pipefd_=pipefd[0]; + // parent exits here, call waitForScript to cleanup up zombie + return; + } + // child code, exec the script + int fd; + for (fd=getdtablesize();fd>=0;--fd) // close all file descriptors + if(fd != pipefd[1]) close(fd); + + fd = open("/dev/null",O_RDWR); // stdin + if(fd == -1) + cLog.msg(Log::PRIO_WARNING) << "can't open stdin"; + else { + if(dup(fd) == -1) // stdout + cLog.msg(Log::PRIO_WARNING) << "can't open stdout"; + if(dup(fd) == -1) // stderr + cLog.msg(Log::PRIO_WARNING) << "can't open stderr"; + } + + char** argv = new char*[args.size() + 2]; + argv[0] = new char[script.size() + 1]; + std::strcpy(argv[0], script.c_str()); + for(unsigned int i=0; i= static_cast(sizeof(err))) { + cLog.msg(Log::PRIO_NOTICE) << "script '" << script_ << "' exec() error: " << AnytunErrno(err); + close(pipefd_); + return_code_ = -1; + return return_code_; + } + } + + close(pipefd_); + closed_ = true; + return_code_ = status; + + return return_code_; +} + +void SysExec::waitAndDestroy(SysExec*& s) +{ + if(!s) + return; + + s->waitForScript(); + if(WIFEXITED(s->return_code_)) + cLog.msg(Log::PRIO_NOTICE) << "script '" << s->script_ << "' returned " << WEXITSTATUS(s->return_code_); + else if(WIFSIGNALED(s->return_code_)) + cLog.msg(Log::PRIO_NOTICE) << "script '" << s->script_ << "' terminated after signal " << WTERMSIG(s->return_code_); + else + cLog.msg(Log::PRIO_ERROR) << "executing script '" << s->script_ << "': unknown error"; + + delete(s); + s = NULL; +} + +#endif // ANYTUN_sysexec_hpp_INCLUDED \ No newline at end of file diff --git a/src/sysExec.cpp b/src/sysExec.cpp index 07615e6..6e291d9 100644 --- a/src/sysExec.cpp +++ b/src/sysExec.cpp @@ -38,15 +38,13 @@ #include "log.h" #include "anytunError.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include +//use system specific signal handler +#ifndef _MSC_VER +#include "sysExec.hpp" +#else + #include "win32/sysExec.hpp" +#endif + SysExec::SysExec(std::string const& script) : script_(script),closed_(false),return_code_(0) { @@ -68,121 +66,7 @@ SysExec::SysExec(std::string const& script, StringVector const& args, StringList doExec( script, args, env); } -SysExec::~SysExec() -{ - if(!closed_) - close(pipefd_); -} - -void SysExec::doExec(std::string const& script, StringVector const& args, StringList const& env) -{ - int pipefd[2]; - if(pipe(pipefd) == -1) { - cLog.msg(Log::PRIO_ERROR) << "executing script '" << script << "' pipe() error: " << AnytunErrno(errno); - return; - } - - pid_ = fork(); - if(pid_ == -1) { - cLog.msg(Log::PRIO_ERROR) << "executing script '" << script << "' fork() error: " << AnytunErrno(errno); - return; - } - - if(pid_) { - close(pipefd[1]); - pipefd_=pipefd[0]; - // parent exits here, call waitForScript to cleanup up zombie - return; - } - // child code, exec the script - int fd; - for (fd=getdtablesize();fd>=0;--fd) // close all file descriptors - if(fd != pipefd[1]) close(fd); - - fd = open("/dev/null",O_RDWR); // stdin - if(fd == -1) - cLog.msg(Log::PRIO_WARNING) << "can't open stdin"; - else { - if(dup(fd) == -1) // stdout - cLog.msg(Log::PRIO_WARNING) << "can't open stdout"; - if(dup(fd) == -1) // stderr - cLog.msg(Log::PRIO_WARNING) << "can't open stderr"; - } - - char** argv = new char*[args.size() + 2]; - argv[0] = new char[script.size() + 1]; - std::strcpy(argv[0], script.c_str()); - for(unsigned int i=0; isize() + 1]; - std::strcpy(evp[i], it->c_str()); - ++i; - } - evp[env.size()] = NULL; - - execve(script.c_str(), argv, evp); - // if execve returns, an error occurred, but logging doesn't work - // because we closed all file descriptors, so just write errno to - // pipe and call exit - int err = errno; - int ret = write(pipefd[1], (void*)(&err), sizeof(err)); - if(ret != sizeof(errno)) - exit(-2); - exit(-1); -} - -int SysExec::waitForScript() -{ - int status = 0; - waitpid(pid_, &status, 0); - - fd_set rfds; - FD_ZERO(&rfds); - FD_SET(pipefd_, &rfds); - struct timeval tv = { 0 , 0 }; - if(select(pipefd_+1, &rfds, NULL, NULL, &tv) == 1) { - int err = 0; - if(read(pipefd_, (void*)(&err), sizeof(err)) >= static_cast(sizeof(err))) { - cLog.msg(Log::PRIO_NOTICE) << "script '" << script_ << "' exec() error: " << AnytunErrno(err); - close(pipefd_); - return_code_ = -1; - return return_code_; - } - } - - close(pipefd_); - closed_ = true; - return_code_ = status; - - return return_code_; -} - int SysExec::getReturnCode() const { return return_code_; } - -void SysExec::waitAndDestroy(SysExec*& s) -{ - if(!s) - return; - - s->waitForScript(); - if(WIFEXITED(s->return_code_)) - cLog.msg(Log::PRIO_NOTICE) << "script '" << s->script_ << "' returned " << WEXITSTATUS(s->return_code_); - else if(WIFSIGNALED(s->return_code_)) - cLog.msg(Log::PRIO_NOTICE) << "script '" << s->script_ << "' terminated after signal " << WTERMSIG(s->return_code_); - else - cLog.msg(Log::PRIO_ERROR) << "executing script '" << s->script_ << "': unknown error"; - - delete(s); - s = NULL; -} diff --git a/src/sysExec.h b/src/sysExec.h index 268384a..28e6d23 100644 --- a/src/sysExec.h +++ b/src/sysExec.h @@ -57,13 +57,20 @@ class SysExec static void waitAndDestroy(SysExec*& s); private: - void doExec(std::string const& script, StringVector const& args, StringList const& env); + void doExec(std::string const& script, StringVector const& args, StringList const& env); std::string script_; + +#ifdef _MSC_VER + PROCESS_INFORMATION process_info_; + DWORD return_code_; +#else pid_t pid_; int pipefd_; - bool closed_; int return_code_; +#endif + bool closed_; + }; #endif diff --git a/src/win32/sysExec.hpp b/src/win32/sysExec.hpp new file mode 100644 index 0000000..d04ed40 --- /dev/null +++ b/src/win32/sysExec.hpp @@ -0,0 +1,160 @@ +/* + * anytun + * + * The secure anycast tunneling protocol (satp) defines a protocol used + * for communication between any combination of unicast and anycast + * tunnel endpoints. It has less protocol overhead than IPSec in Tunnel + * mode and allows tunneling of every ETHER TYPE protocol (e.g. + * ethernet, ip, arp ...). satp directly includes cryptography and + * message authentication based on the methodes used by SRTP. It is + * intended to deliver a generic, scaleable and secure solution for + * tunneling and relaying of packets of any protocol. + * + * + * Copyright (C) 2007-2009 Othmar Gsenger, Erwin Nindl, + * Christian Pointner + * + * This file is part of Anytun. + * + * Anytun is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. + * + * Anytun is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with anytun. If not, see . + */ +#pragma once +#ifndef ANYTUN_sysexec_hpp_INCLUDED +#define ANYTUN_sysexec_hpp_INCLUDED + +#include +#include // todo remove +#include + +SysExec::~SysExec() +{ + if(!closed_) { + CloseHandle(process_info_.hProcess); + CloseHandle(process_info_.hThread); + } +} + +STARTUPINFOA getStartupInfo() { + STARTUPINFOA startup_info; + startup_info.cb = sizeof(STARTUPINFOA); + GetStartupInfoA(&startup_info); + + //startup_info.dwFlags = STARTF_USESTDHANDLES; + //startup_info.hStdInput = CreateFile("NUL", GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 0, 0, 0); // INVALID_HANDLE_VALUE; + //startup_info.hStdOutput = CreateFile("NUL", GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 0, 0, 0); // INVALID_HANDLE_VALUE; + //startup_info.hStdError = CreateFile("NUL", GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, 0, 0, 0); // INVALID_HANDLE_VALUE; + startup_info.dwFlags |= STARTF_USESHOWWINDOW; + startup_info.wShowWindow = SW_HIDE; + + return startup_info; +} + +char const * const BATCH_FILE_EXTS[] = { ".bat", ".cmd" }; +int const BATCH_FILE_EXTS_COUNT = sizeof(BATCH_FILE_EXTS) / sizeof(BATCH_FILE_EXTS[0]); + +bool endsWith(std::string const& string, std::string const& suffix) { + return string.find(suffix, string.size() - suffix.size()) != std::string::npos; +} + +void SysExec::doExec(std::string const& script, StringVector const& args, StringList const& env) +{ + std::vector arguments; + + bool isBatchFile = false; + for(int i = 0; i < BATCH_FILE_EXTS_COUNT; ++i) { + if(endsWith(script, BATCH_FILE_EXTS[i])) { + isBatchFile = true; + break; + } + } + + if(isBatchFile) { + std::string const BATCH_INTERPRETER = "cmd /c \""; + arguments.insert(arguments.end(), BATCH_INTERPRETER.begin(), BATCH_INTERPRETER.end()); + } + arguments.push_back('\"'); + arguments.insert(arguments.end(), script.begin(), script.end()); + arguments.push_back('\"'); + arguments.push_back(' '); + + for(StringVector::const_iterator it = args.begin(); it != args.end(); ++it) { + arguments.push_back('\"'); + arguments.insert(arguments.end(), it->begin(), it->end()); + arguments.push_back('\"'); + arguments.push_back(' '); + } + + if(isBatchFile) { + arguments.push_back('\"'); + } + arguments.push_back(0); + + STARTUPINFOA startup_info = getStartupInfo(); + + std::map envDict; + for(StringList::const_iterator it = env.begin(); it != env.begin(); ++it) { + size_t delimiter_pos = it->find('='); + envDict.insert(std::make_pair(it->substr(0, delimiter_pos), it->substr(delimiter_pos + 1))); + } + std::vector env; + for(std::map::iterator it = envDict.begin(); it != envDict.end(); ++it) { + env.insert(env.end(), it->first.begin(), it->first.end()); + env.push_back(0); + } + env.push_back(0); + + if(!CreateProcessA(NULL, + &arguments[0], + NULL, + NULL, + false, + NULL, + &env[0], + NULL, + &startup_info, + &process_info_ + )) + { + cLog.msg(Log::PRIO_ERROR) << "executing script '" << script << "' CreateProcess() error: " << GetLastError(); + return; + } +} + +int SysExec::waitForScript() +{ + DWORD result = WaitForSingleObject(process_info_.hProcess, INFINITE); + assert(WAIT_OBJECT_0 == result); // WAIT_FAILED, WAIT_TIMEOUT ... ??? + bool success = GetExitCodeProcess(process_info_.hProcess, &return_code_) != 0; + assert(true == success); // false -> HU? + + CloseHandle(process_info_.hProcess); + CloseHandle(process_info_.hThread); + closed_ = true; + + return static_cast(return_code_); +} + +void SysExec::waitAndDestroy(SysExec*& s) +{ + if(!s) + return; + + s->waitForScript(); + cLog.msg(Log::PRIO_NOTICE) << "script '" << s->script_ << "' returned " << s->return_code_; + + delete(s); + s = NULL; +} + +#endif // ANYTUN_sysexec_hpp_INCLUDED -- cgit v1.2.3