From c78b1a326d96406ccc871b8af618dd209baa76f4 Mon Sep 17 00:00:00 2001 From: Christian Pointner Date: Thu, 28 Feb 2008 17:44:53 +0000 Subject: added generic tool code added anyrtpproxy --- anyrtpproxy/Makefile | 43 ++++++++++++ anyrtpproxy/anyrtpproxy.cpp | 133 +++++++++++++++++++++++++++++++++++ anyrtpproxy/options.cpp | 165 ++++++++++++++++++++++++++++++++++++++++++++ anyrtpproxy/options.h | 72 +++++++++++++++++++ openser-config/openser.cfg | 136 ++++++++++++++++++++++++++++++++++++ plain_tool/Makefile | 39 +++++++++++ plain_tool/options.cpp | 165 ++++++++++++++++++++++++++++++++++++++++++++ plain_tool/options.h | 72 +++++++++++++++++++ plain_tool/plain_tool.cpp | 101 +++++++++++++++++++++++++++ 9 files changed, 926 insertions(+) create mode 100644 anyrtpproxy/Makefile create mode 100644 anyrtpproxy/anyrtpproxy.cpp create mode 100644 anyrtpproxy/options.cpp create mode 100644 anyrtpproxy/options.h create mode 100644 openser-config/openser.cfg create mode 100644 plain_tool/Makefile create mode 100644 plain_tool/options.cpp create mode 100644 plain_tool/options.h create mode 100644 plain_tool/plain_tool.cpp diff --git a/anyrtpproxy/Makefile b/anyrtpproxy/Makefile new file mode 100644 index 0000000..952f915 --- /dev/null +++ b/anyrtpproxy/Makefile @@ -0,0 +1,43 @@ +C = gcc +CFLAGS = -g -Wall +C++ = g++ +CCFLAGS = -g -Wall +LD = g++ +LDFLAGS = -g -Wall -O2 -lpthread + +OBJS = anyrtpproxy.o \ + signalController.o \ + PracticalSocket.o \ + log.o \ + buffer.o \ + options.o + +EXECUTABLE = anyrtpproxy + +all: $(EXECUTABLE) + +anyrtpproxy: $(OBJS) + $(LD) $(OBJS) -o $@ $(LDFLAGS) + +signalController.o: ../signalController.cpp ../signalController.h + $(C++) $(CCFLAGS) $< -c + +PracticalSocket.o: ../PracticalSocket.cpp ../PracticalSocket.h + $(C++) $(CCFLAGS) $< -c + +log.o: ../log.cpp ../log.h + $(C++) $(CCFLAGS) $< -c + +buffer.o: ../buffer.cpp ../buffer.h + $(C++) $(CCFLAGS) $< -c + +options.o: options.cpp options.h + $(C++) $(CCFLAGS) $< -c + +anyrtpproxy.o: anyrtpproxy.cpp + $(C++) $(CCFLAGS) $< -c + +clean: + rm -f *.o + rm -f $(EXECUTABLE) + diff --git a/anyrtpproxy/anyrtpproxy.cpp b/anyrtpproxy/anyrtpproxy.cpp new file mode 100644 index 0000000..b5998e2 --- /dev/null +++ b/anyrtpproxy/anyrtpproxy.cpp @@ -0,0 +1,133 @@ +#include + +#include "../datatypes.h" + +#include "../log.h" +#include "../signalController.h" +#include "../PracticalSocket.h" +#include "../buffer.h" + +#include "options.h" + +#define MAX_PACKET_SIZE 1500 + +void* worker(void* dont_use_me) +{ + try + { + + UDPSocket sock("127.0.0.1", 22222); + Buffer buf(u_int32_t(MAX_PACKET_SIZE)); + + while(1) { + string remote_host; + u_int16_t remote_port; + + buf.setLength(MAX_PACKET_SIZE); + u_int32_t len = sock.recvFrom(buf.getBuf(), buf.getLength(), remote_host, remote_port); + buf.setLength(len); + + std::cout << "Received UDP Packet from: " << remote_host << ":" << remote_port << std::endl; + std::cout << buf.getHexDump() << std::endl; + +// sendTo(buf, len, addr, port); + } + } + catch(std::exception &e) + { + std::cout << "an error happend: " << e.what() << std::endl; + } + pthread_exit(NULL); +} + + + + + +// void chrootAndDrop(string const& chrootdir, string const& username) +// { +// if (getuid() != 0) +// { +// std::cerr << "this programm has to be run as root in order to run in a chroot" << std::endl; +// exit(-1); +// } + +// struct passwd *pw = getpwnam(username.c_str()); +// if(pw) { +// if(chroot(chrootdir.c_str())) +// { +// std::cerr << "can't chroot to " << chrootdir << std::endl; +// exit(-1); +// } +// std::cout << "we are in chroot jail (" << chrootdir << ") now" << std::endl; +// chdir("/"); +// if (initgroups(pw->pw_name, pw->pw_gid) || setgid(pw->pw_gid) || setuid(pw->pw_uid)) +// { +// std::cerr << "can't drop to user " << username << " " << pw->pw_uid << ":" << pw->pw_gid << std::endl; +// exit(-1); +// } +// std::cout << "dropped user to " << username << " " << pw->pw_uid << ":" << pw->pw_gid << std::endl; +// } +// else +// { +// std::cerr << "unknown user " << username << std::endl; +// exit(-1); +// } +// } + +// void daemonize() +// { +// pid_t pid; + +// pid = fork(); +// if(pid) exit(0); +// setsid(); +// pid = fork(); +// if(pid) exit(0); + +// std::cout << "running in background now..." << std::endl; + +// int fd; +// for (fd=getdtablesize();fd>=0;--fd) // close all file descriptors +// close(fd); +// fd=open("/dev/null",O_RDWR); // stdin +// dup(fd); // stdout +// dup(fd); // stderr +// umask(027); +// } + + +int main(int argc, char* argv[]) +{ + std::cout << "anyrtpproxy" << std::endl; + if(!gOpt.parse(argc, argv)) + { + gOpt.printUsage(); + exit(-1); + } + +// if(gOpt.chroot) +// chrootAndDrop(gOpt.getChrootDir, gOpt.getUsername); +// if(testSetPid(gOpt.pidFilename)) +// { +// std::cout << "exiting..." << std::endl; +// return -1; +// } +// if(gOpt.daemonize) +// daemonize(gOpt.pidFilename); + + + cLog.msg(Log::PRIO_NOTICE) << "anyrtpproxy started..."; + + SignalController sig; + sig.init(); + + pthread_t workerThread; + pthread_create(&workerThread, NULL, worker, NULL); + pthread_detach(workerThread); + + int ret = sig.run(); + + return ret; +} + diff --git a/anyrtpproxy/options.cpp b/anyrtpproxy/options.cpp new file mode 100644 index 0000000..6901a07 --- /dev/null +++ b/anyrtpproxy/options.cpp @@ -0,0 +1,165 @@ +/* + * 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 anytun.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation. + * + * This program 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 this program (see the file COPYING included with this + * distribution); if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include +#include +#include +#include + +#include "options.h" + +Options* Options::inst = NULL; +Mutex Options::instMutex; +Options& gOpt = Options::instance(); + +Options& Options::instance() +{ + Lock lock(instMutex); + static instanceCleaner c; + if(!inst) + inst = new Options(); + + return *inst; +} + +Options::Options() +{ + progname_ = "plain_tool"; +} + +Options::~Options() +{ +} + +#define PARSE_BOOL_PARAM(SHORT, LONG, VALUE) \ + else if(str == SHORT || str == LONG) \ + VALUE = true; + +#define PARSE_INVERSE_BOOL_PARAM(SHORT, LONG, VALUE) \ + else if(str == SHORT || str == LONG) \ + VALUE = false; + +#define PARSE_SCALAR_PARAM(SHORT, LONG, VALUE) \ + else if(str == SHORT || str == LONG) \ + { \ + if(argc < 1 || argv[i+1][0] == '-') \ + return false; \ + std::stringstream tmp; \ + tmp << argv[i+1]; \ + tmp >> VALUE; \ + argc--; \ + i++; \ + } + +#define PARSE_SCALAR_PARAM2(SHORT, LONG, VALUE1, VALUE2) \ + else if(str == SHORT || str == LONG) \ + { \ + if(argc < 2 || \ + argv[i+1][0] == '-' || argv[i+2][0] == '-') \ + return false; \ + std::stringstream tmp; \ + tmp << argv[i+1] << " " << argv[i+2]; \ + tmp >> VALUE1; \ + tmp >> VALUE2; \ + argc-=2; \ + i+=2; \ + } + +#define PARSE_HEXSTRING_PARAM(SHORT, LONG, VALUE) \ + else if(str == SHORT || str == LONG) \ + { \ + if(argc < 1 || argv[i+1][0] == '-') \ + return false; \ + VALUE = Buffer(std::string(argv[i+1])); \ + argc--; \ + i++; \ + } + +#define PARSE_CSLIST_PARAM(SHORT, LONG, LIST) \ + else if(str == SHORT || str == LONG) \ + { \ + if(argc < 1 || argv[i+1][0] == '-') \ + return false; \ + std::stringstream tmp(argv[i+1]); \ + while (tmp.good()) \ + { \ + std::string tmp_line; \ + getline(tmp,tmp_line,','); \ + LIST.push(tmp_line); \ + } \ + argc--; \ + i++; \ + } + +bool Options::parse(int argc, char* argv[]) +{ + Lock lock(mutex); + + progname_ = argv[0]; + argc--; + for(int i=1; argc > 0; ++i) + { + std::string str(argv[i]); + argc--; + + if(str == "-h" || str == "--help") + return false; + else + return false; + } + return true; +} + +void Options::printUsage() +{ + std::cout << "USAGE:" << std::endl; + std::cout << "plain_tool [-h|--help] prints this..." << std::endl; +// std::cout << " [-K|--key] master key to use for encryption" << std::endl; +} + +void Options::printOptions() +{ + Lock lock(mutex); + std::cout << "Options:" << std::endl; +} + +std::string Options::getProgname() +{ + Lock lock(mutex); + return progname_; +} + + +Options& Options::setProgname(std::string p) +{ + Lock lock(mutex); + progname_ = p; + return *this; +} diff --git a/anyrtpproxy/options.h b/anyrtpproxy/options.h new file mode 100644 index 0000000..f4aeb5d --- /dev/null +++ b/anyrtpproxy/options.h @@ -0,0 +1,72 @@ +/* + * 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 anytun.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation. + * + * This program 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 this program (see the file COPYING included with this + * distribution); if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef _OPTIONS_H_ +#define _OPTIONS_H_ + +#include "../threadUtils.hpp" + +class Options +{ +public: + static Options& instance(); + + bool parse(int argc, char* argv[]); + void printUsage(); + void printOptions(); + + std::string getProgname(); + Options& setProgname(std::string p); + + +private: + Options(); + ~Options(); + Options(const Options &l); + void operator=(const Options &l); + + static Options* inst; + static Mutex instMutex; + class instanceCleaner { + public: ~instanceCleaner() { + if(Options::inst != 0) + delete Options::inst; + } + }; + friend class instanceCleaner; + + Mutex mutex; + + std::string progname_; +}; + +extern Options& gOpt; + +#endif diff --git a/openser-config/openser.cfg b/openser-config/openser.cfg new file mode 100644 index 0000000..193acd0 --- /dev/null +++ b/openser-config/openser.cfg @@ -0,0 +1,136 @@ +# +# ----------- global configuration parameters ------------------------ + +fork=yes +#listen=83.64.208.28 +port=5060 +log_stderror=no +debug=3 + +check_via=no # (cmd. line: -v) +dns=no # (cmd. line: -r) +rev_dns=no # (cmd. line: -R) +children=4 +fifo="/tmp/openser_fifo" + +# ------------------ module loading ---------------------------------- + +loadmodule "/usr/lib/openser/modules/sl.so" +loadmodule "/usr/lib/openser/modules/tm.so" +loadmodule "/usr/lib/openser/modules/rr.so" +loadmodule "/usr/lib/openser/modules/textops.so" +loadmodule "/usr/lib/openser/modules/maxfwd.so" +loadmodule "/usr/lib/openser/modules/usrloc.so" +loadmodule "/usr/lib/openser/modules/registrar.so" + +loadmodule "/usr/lib/openser/modules/nathelper.so" + +loadmodule "/usr/lib/openser/modules/xlog.so" + + +## ----------------- setting module-specific parameters --------------- + +modparam("usrloc", "db_mode", 0) + +modparam("rr", "enable_full_lr", 1) + +modparam("nathelper", "rtpproxy_sock", "udp:localhost:22222") + +# ------------------------- request routing logic ------------------- + +route{ + xlog("L_ERR", "@route: method <$rm> r-uri <$ru>\n"); + + # initial sanity checks -- messages with + # max_forwards==0, or excessively long requests + if (!mf_process_maxfwd_header("10")) { + sl_send_reply("483","Too Many Hops"); + exit; + }; + + if (msg:len >= 2048 ) { + sl_send_reply("513", "Message too big"); + exit; + }; + + # we record-route all messages -- to make sure that + # subsequent messages will go through our proxy; that's + # particularly good if upstream and downstream entities + # use different transport protocol + if (method!="REGISTER") + record_route(); + + + if (method=="BYE" || method=="CANCEL") { + unforce_rtp_proxy(); + }; + + # subsequent messages withing a dialog should take the + # path determined by record-routing + if (loose_route()) { + if (method=="INVITE") { + route(3); + }; + route(1); + }; + + if (!uri==myself) { + if (method=="INVITE") { + route(3); + }; + route(1); + }; + + if (method=="ACK") { + route(1); + } else if (method=="REGISTER") { + route(2); + }; + + lookup("aliases"); + if (uri!=myself) { + if (method=="INVITE") { + route(3); + }; + route(1); + }; + + # native SIP destinations are handled using our USRLOC DB + if (!lookup("location")) { + sl_send_reply("404", "Not Found"); + exit; + }; + + if (method=="INVITE") { + route(3); + }; + + route(1); +} + + +route[1] { + # send it out now; use stateful forwarding as it works reliably + # even for UDP2TCP + if (!t_relay()) { + sl_reply_error(); + }; + exit; +} + +route[2] { + if (!save("location")) { + sl_reply_error(); + }; + exit; +} + +route[3] { + force_rtp_proxy("","83.64.208.28"); +} + +onreply_route { + if (!search("^Content-Length:[ ]*0")) { + route(3); + }; +} diff --git a/plain_tool/Makefile b/plain_tool/Makefile new file mode 100644 index 0000000..e35d6b1 --- /dev/null +++ b/plain_tool/Makefile @@ -0,0 +1,39 @@ +C = gcc +CFLAGS = -g -Wall +C++ = g++ +CCFLAGS = -g -Wall +LD = g++ +LDFLAGS = -g -Wall -O2 -lpthread + +OBJS = plain_tool.o \ + signalController.o \ + PracticalSocket.o \ + log.o \ + options.o + +EXECUTABLE = plain_tool + +all: $(EXECUTABLE) + +plain_tool: $(OBJS) + $(LD) $(OBJS) -o $@ $(LDFLAGS) + +signalController.o: ../signalController.cpp ../signalController.h + $(C++) $(CCFLAGS) $< -c + +PracticalSocket.o: ../PracticalSocket.cpp ../PracticalSocket.h + $(C++) $(CCFLAGS) $< -c + +log.o: ../log.cpp ../log.h + $(C++) $(CCFLAGS) $< -c + +options.o: options.cpp options.h + $(C++) $(CCFLAGS) $< -c + +plain_tool.o: plain_tool.cpp + $(C++) $(CCFLAGS) $< -c + +clean: + rm -f *.o + rm -f $(EXECUTABLE) + diff --git a/plain_tool/options.cpp b/plain_tool/options.cpp new file mode 100644 index 0000000..1dcf8a2 --- /dev/null +++ b/plain_tool/options.cpp @@ -0,0 +1,165 @@ +/* + * 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 anytun.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation. + * + * This program 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 this program (see the file COPYING included with this + * distribution); if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include +#include +#include +#include + +#include "options.h" + +Options* Options::inst = NULL; +Mutex Options::instMutex; +Options& gOpt = Options::instance(); + +Options& Options::instance() +{ + Lock lock(instMutex); + static instanceCleaner c; + if(!inst) + inst = new Options(); + + return *inst; +} + +Options::Options() +{ + progname_ = "anyrtpproxy"; +} + +Options::~Options() +{ +} + +#define PARSE_BOOL_PARAM(SHORT, LONG, VALUE) \ + else if(str == SHORT || str == LONG) \ + VALUE = true; + +#define PARSE_INVERSE_BOOL_PARAM(SHORT, LONG, VALUE) \ + else if(str == SHORT || str == LONG) \ + VALUE = false; + +#define PARSE_SCALAR_PARAM(SHORT, LONG, VALUE) \ + else if(str == SHORT || str == LONG) \ + { \ + if(argc < 1 || argv[i+1][0] == '-') \ + return false; \ + std::stringstream tmp; \ + tmp << argv[i+1]; \ + tmp >> VALUE; \ + argc--; \ + i++; \ + } + +#define PARSE_SCALAR_PARAM2(SHORT, LONG, VALUE1, VALUE2) \ + else if(str == SHORT || str == LONG) \ + { \ + if(argc < 2 || \ + argv[i+1][0] == '-' || argv[i+2][0] == '-') \ + return false; \ + std::stringstream tmp; \ + tmp << argv[i+1] << " " << argv[i+2]; \ + tmp >> VALUE1; \ + tmp >> VALUE2; \ + argc-=2; \ + i+=2; \ + } + +#define PARSE_HEXSTRING_PARAM(SHORT, LONG, VALUE) \ + else if(str == SHORT || str == LONG) \ + { \ + if(argc < 1 || argv[i+1][0] == '-') \ + return false; \ + VALUE = Buffer(std::string(argv[i+1])); \ + argc--; \ + i++; \ + } + +#define PARSE_CSLIST_PARAM(SHORT, LONG, LIST) \ + else if(str == SHORT || str == LONG) \ + { \ + if(argc < 1 || argv[i+1][0] == '-') \ + return false; \ + std::stringstream tmp(argv[i+1]); \ + while (tmp.good()) \ + { \ + std::string tmp_line; \ + getline(tmp,tmp_line,','); \ + LIST.push(tmp_line); \ + } \ + argc--; \ + i++; \ + } + +bool Options::parse(int argc, char* argv[]) +{ + Lock lock(mutex); + + progname_ = argv[0]; + argc--; + for(int i=1; argc > 0; ++i) + { + std::string str(argv[i]); + argc--; + + if(str == "-h" || str == "--help") + return false; + else + return false; + } + return true; +} + +void Options::printUsage() +{ + std::cout << "USAGE:" << std::endl; + std::cout << "anyrtpproxy [-h|--help] prints this..." << std::endl; +// std::cout << " [-K|--key] master key to use for encryption" << std::endl; +} + +void Options::printOptions() +{ + Lock lock(mutex); + std::cout << "Options:" << std::endl; +} + +std::string Options::getProgname() +{ + Lock lock(mutex); + return progname_; +} + + +Options& Options::setProgname(std::string p) +{ + Lock lock(mutex); + progname_ = p; + return *this; +} diff --git a/plain_tool/options.h b/plain_tool/options.h new file mode 100644 index 0000000..f4aeb5d --- /dev/null +++ b/plain_tool/options.h @@ -0,0 +1,72 @@ +/* + * 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 anytun.org + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation. + * + * This program 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 this program (see the file COPYING included with this + * distribution); if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef _OPTIONS_H_ +#define _OPTIONS_H_ + +#include "../threadUtils.hpp" + +class Options +{ +public: + static Options& instance(); + + bool parse(int argc, char* argv[]); + void printUsage(); + void printOptions(); + + std::string getProgname(); + Options& setProgname(std::string p); + + +private: + Options(); + ~Options(); + Options(const Options &l); + void operator=(const Options &l); + + static Options* inst; + static Mutex instMutex; + class instanceCleaner { + public: ~instanceCleaner() { + if(Options::inst != 0) + delete Options::inst; + } + }; + friend class instanceCleaner; + + Mutex mutex; + + std::string progname_; +}; + +extern Options& gOpt; + +#endif diff --git a/plain_tool/plain_tool.cpp b/plain_tool/plain_tool.cpp new file mode 100644 index 0000000..a9bbfbd --- /dev/null +++ b/plain_tool/plain_tool.cpp @@ -0,0 +1,101 @@ +#include + +#include "../datatypes.h" + +#include "../log.h" +#include "../signalController.h" + +#include "options.h" + + +// void chrootAndDrop(string const& chrootdir, string const& username) +// { +// if (getuid() != 0) +// { +// std::cerr << "this programm has to be run as root in order to run in a chroot" << std::endl; +// exit(-1); +// } + +// struct passwd *pw = getpwnam(username.c_str()); +// if(pw) { +// if(chroot(chrootdir.c_str())) +// { +// std::cerr << "can't chroot to " << chrootdir << std::endl; +// exit(-1); +// } +// std::cout << "we are in chroot jail (" << chrootdir << ") now" << std::endl; +// chdir("/"); +// if (initgroups(pw->pw_name, pw->pw_gid) || setgid(pw->pw_gid) || setuid(pw->pw_uid)) +// { +// std::cerr << "can't drop to user " << username << " " << pw->pw_uid << ":" << pw->pw_gid << std::endl; +// exit(-1); +// } +// std::cout << "dropped user to " << username << " " << pw->pw_uid << ":" << pw->pw_gid << std::endl; +// } +// else +// { +// std::cerr << "unknown user " << username << std::endl; +// exit(-1); +// } +// } + +// void daemonize() +// { +// pid_t pid; + +// pid = fork(); +// if(pid) exit(0); +// setsid(); +// pid = fork(); +// if(pid) exit(0); + +// std::cout << "running in background now..." << std::endl; + +// int fd; +// for (fd=getdtablesize();fd>=0;--fd) // close all file descriptors +// close(fd); +// fd=open("/dev/null",O_RDWR); // stdin +// dup(fd); // stdout +// dup(fd); // stderr +// umask(027); +// } + + +int main(int argc, char* argv[]) +{ + std::cout << "plain_tool" << std::endl; + if(!gOpt.parse(argc, argv)) + { + gOpt.printUsage(); + exit(-1); + } + +// if(gOpt.chroot) +// chrootAndDrop(gOpt.getChrootDir, gOpt.getUsername); +// if(testSetPid(gOpt.pidFilename)) +// { +// std::cout << "exiting..." << std::endl; +// return -1; +// } +// if(gOpt.daemonize) +// daemonize(gOpt.pidFilename); + + + cLog.msg(Log::PRIO_NOTICE) << "plain_tool started..."; + + SignalController sig; + sig.init(); + +// pthread_t senderThread; +// pthread_create(&senderThread, NULL, sender, &p); +// pthread_detach(senderThread); + + + + + int ret = sig.run(); + + + return ret; +} + -- cgit v1.2.3