diff options
| -rw-r--r-- | src/Makefile | 9 | ||||
| -rw-r--r-- | src/anytun.cpp | 9 | ||||
| -rw-r--r-- | src/resolver.cpp | 105 | ||||
| -rw-r--r-- | src/resolver.h | 90 |
4 files changed, 210 insertions, 3 deletions
diff --git a/src/Makefile b/src/Makefile index be5ec6e..4f75c70 100644 --- a/src/Makefile +++ b/src/Makefile @@ -56,7 +56,8 @@ OBJS := tunDevice.o \ anytunError.o \ options.o \ seqWindow.o \ - routingTreeNode.o + routingTreeNode.o \ + resolver.o SYNCOBJS := syncServer.o \ syncClient.o \ @@ -73,7 +74,8 @@ ANYCTROBJS := signalController.o \ logTargets.o \ anytunError.o \ syncTcpConnection.o \ - syncServer.o + syncServer.o \ + resolver.o ANYCONFOBJS := log.o \ logTargets.o \ @@ -95,7 +97,8 @@ ANYCONFOBJS := log.o \ syncServer.o \ syncTcpConnection.o \ syncRouteCommand.o \ - syncConnectionCommand.o + syncConnectionCommand.o \ + resolver.o EXECUTABLE := anytun anytun-config anytun-controld anytun-showtables anytun-nosync EXEOBJS := anytun.o anytun-config.o anytun-controld.o anytun-showtables.o diff --git a/src/anytun.cpp b/src/anytun.cpp index 4086c93..bd21eb3 100644 --- a/src/anytun.cpp +++ b/src/anytun.cpp @@ -39,6 +39,7 @@ #include "datatypes.h" #include "log.h" +#include "resolver.h" #include "buffer.h" #include "plainPacket.h" #include "encryptedPacket.h" @@ -395,6 +396,14 @@ int main(int argc, char* argv[]) cLog.msg(Log::PRIO_NOTICE) << "anytun started..."; gOpt.parse_post(); // print warnings +// gResolver.init(); +// gResolver.resolveUdp(gOpt.getRemoteAddr(), gOpt.getRemotePort()); +// gResolver.resolveTcp(gOpt.getRemoteAddr(), gOpt.getRemotePort()); + +// while(1) +// boost::this_thread::sleep(boost::posix_time::milliseconds(1000)); +// exit(0); + #ifndef NO_DAEMON #ifndef NO_PRIVDROP PrivInfo privs(gOpt.getUsername(), gOpt.getGroupname()); diff --git a/src/resolver.cpp b/src/resolver.cpp new file mode 100644 index 0000000..52d0c0b --- /dev/null +++ b/src/resolver.cpp @@ -0,0 +1,105 @@ +/* + * 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-2008 Othmar Gsenger, Erwin Nindl, + * Christian Pointner <satp@wirdorange.org> + * + * 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 version 3 as + * published by the Free Software Foundation. + * + * 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 <http://www.gnu.org/licenses/>. + */ + +#include <boost/bind.hpp> + +#include "resolver.h" +#include "log.h" + +template<class Proto> ResolveHandler<Proto>::ResolveHandler(const std::string& addr, const std::string& port) : addr_(addr), port_(port) +{ +} + +template<class Proto> void ResolveHandler<Proto>::operator()(const boost::system::error_code& e, const boost::asio::ip::basic_resolver_iterator<Proto>) +{ + cLog.msg(Log::PRIO_DEBUG) << "ResolveHandler<" << typeid(Proto).name() << ">() called, addr='" << addr_ << "', port='" << port_ << "'"; +} + +Resolver* Resolver::inst = NULL; +Mutex Resolver::instMutex; +Resolver& gResolver = Resolver::instance(); + +Resolver& Resolver::instance() +{ + Lock lock(instMutex); + static instanceCleaner c; + if(!inst) + inst = new Resolver(); + + return *inst; +} + +Resolver::Resolver() : udp_resolver_(io_service_), tcp_resolver_(io_service_), thread_(NULL) +{ +} + +Resolver::~Resolver() +{ + if(thread_) + delete thread_; +} + +void Resolver::init() +{ + if(!thread_) + thread_ = new boost::thread(boost::bind(run, this)); +} + +void Resolver::run(void* s) +{ + Resolver* self = reinterpret_cast<Resolver*>(s); + + cLog.msg(Log::PRIO_DEBUG) << "Resolver Thread started"; + + while(1) { + self->io_service_.run(); + self->io_service_.reset(); + boost::this_thread::sleep(boost::posix_time::milliseconds(250)); + } +} + +void Resolver::resolveUdp(const std::string& addr, const std::string& port) +{ + cLog.msg(Log::PRIO_DEBUG) << "trying to resolv UDP: " << addr << " " << port; + + boost::asio::ip::udp::resolver::query query(addr, port); + UdpResolveHandler handler(addr, port); + udp_resolver_.async_resolve(query, handler); +} + +void Resolver::resolveTcp(const std::string& addr, const std::string& port) +{ + cLog.msg(Log::PRIO_DEBUG) << "trying to resolv TCP: " << addr << " " << port; + + boost::asio::ip::tcp::resolver::query query(addr, port); + TcpResolveHandler handler(addr, port); + tcp_resolver_.async_resolve(query, handler); +} diff --git a/src/resolver.h b/src/resolver.h new file mode 100644 index 0000000..7f1336f --- /dev/null +++ b/src/resolver.h @@ -0,0 +1,90 @@ +/* + * 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-2008 Othmar Gsenger, Erwin Nindl, + * Christian Pointner <satp@wirdorange.org> + * + * 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 version 3 as + * published by the Free Software Foundation. + * + * 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 <http://www.gnu.org/licenses/>. + */ + +#ifndef _RESOLVER_H_ +#define _RESOLVER_H_ + +#include <queue> +#include <boost/asio.hpp> + +#include "threadUtils.hpp" + +template<class Proto> +class ResolveHandler +{ +public: + ResolveHandler(const std::string& addr, const std::string& port); + void operator()(const boost::system::error_code& e, const boost::asio::ip::basic_resolver_iterator<Proto>); + +private: + std::string addr_; + std::string port_; +}; + +typedef ResolveHandler<boost::asio::ip::udp> UdpResolveHandler; +typedef ResolveHandler<boost::asio::ip::tcp> TcpResolveHandler; + +class Resolver +{ +public: + static Resolver& instance(); + + void init(); + static void run(void* s); + + void resolveUdp(const std::string& addr, const std::string& port); + void resolveTcp(const std::string& addr, const std::string& port); + +private: + Resolver(); + ~Resolver(); + Resolver(const Resolver &r); + void operator=(const Resolver &r); + + static Resolver* inst; + static ::Mutex instMutex; + class instanceCleaner { + public: ~instanceCleaner() { + if(Resolver::inst != 0) + delete Resolver::inst; + } + }; + friend class instanceCleaner; + + boost::asio::io_service io_service_; + boost::asio::ip::udp::resolver udp_resolver_; + boost::asio::ip::tcp::resolver tcp_resolver_; + boost::thread* thread_; +}; + +extern Resolver& gResolver; + +#endif |