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 --- plain_tool/Makefile | 39 +++++++++++ plain_tool/options.cpp | 165 ++++++++++++++++++++++++++++++++++++++++++++++ plain_tool/options.h | 72 ++++++++++++++++++++ plain_tool/plain_tool.cpp | 101 ++++++++++++++++++++++++++++ 4 files changed, 377 insertions(+) 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 (limited to 'plain_tool') 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