summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--anyrtpproxy/Makefile43
-rw-r--r--anyrtpproxy/anyrtpproxy.cpp133
-rw-r--r--anyrtpproxy/options.cpp165
-rw-r--r--anyrtpproxy/options.h72
-rw-r--r--openser-config/openser.cfg136
-rw-r--r--plain_tool/Makefile39
-rw-r--r--plain_tool/options.cpp165
-rw-r--r--plain_tool/options.h72
-rw-r--r--plain_tool/plain_tool.cpp101
9 files changed, 926 insertions, 0 deletions
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 <iostream>
+
+#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 <satp@wirdorange.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 <iostream>
+#include <queue>
+#include <string>
+#include <sstream>
+
+#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> 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 <satp@wirdorange.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 <satp@wirdorange.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 <iostream>
+#include <queue>
+#include <string>
+#include <sstream>
+
+#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> 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 <satp@wirdorange.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 <iostream>
+
+#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;
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-06 01:12:43 +0000