* 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
+ * message authentication based on the methods 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,
+ * Copyright (C) 2007-2014 Markus Grüneis, 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.
+ * 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
* 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/>.
+ * along with Anytun. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * In addition, as a special exception, the copyright holders give
+ * permission to link the code of portions of this program with the
+ * OpenSSL library under certain conditions as described in each
+ * individual source file, and distribute linked combinations
+ * including the two.
+ * You must obey the GNU General Public License in all respects
+ * for all of the code used other than OpenSSL. If you modify
+ * file(s) with this exception, you may extend this exception to your
+ * version of the file(s), but you are not obligated to do so. If you
+ * do not wish to do so, delete this exception statement from your
+ * version. If you delete this exception statement from all source
+ * files in the program, then also delete it here.
*/
#include <boost/bind.hpp>
using ::boost::asio::ip::tcp;
template<class Proto>
-void waitAndEnqueue(u
_int32_t s, const std::string& addr, const std::string& port, boost::function<void(boost::asio::ip::basic_endpoint<Proto>)> const& onResolve, ErrorCallback const& onError, ResolvAddrType r)
+void waitAndEnqueue(u
int32_t s, const std::string& addr, const std::string& port, boost::function<void(boost::asio::ip::basic_resolver_iterator<Proto>)> const& onResolve, ErrorCallback const& onError, ResolvAddrType r)
{
cLog.msg(Log::PRIO_ERROR) << "the resolver only supports udp and tcp";
}
template<>
-void waitAndEnqueue(u_int32_t s, const std::string& addr, const std::string& port, boost::function<void(boost::asio::ip::basic_endpoint<udp>)> const& onResolve, ErrorCallback const& onError, ResolvAddrType r)
+void waitAndEnqueue(uint32_t s, const std::string& addr, const std::string& port, boost::function<void(boost::asio::ip::basic_resolver_iterator<udp>)> const& onResolve, ErrorCallback const& onError, ResolvAddrType r)
{
boost::this_thread::sleep(boost::posix_time::milliseconds(s * 1000));
gResolver.resolveUdp(addr, port, onResolve, onError, r);
}
template<>
-void waitAndEnqueue(u_int32_t s, const std::string& addr, const std::string& port, boost::function<void(boost::asio::ip::basic_endpoint<tcp>)> const& onResolve, ErrorCallback const& onError, ResolvAddrType r)
+void waitAndEnqueue(uint32_t s, const std::string& addr, const std::string& port, boost::function<void(boost::asio::ip::basic_resolver_iterator<tcp>)> const& onResolve, ErrorCallback const& onError, ResolvAddrType r)
{
boost::this_thread::sleep(boost::posix_time::milliseconds(s * 1000));
gResolver.resolveTcp(addr, port, onResolve, onError, r);
template<class Proto>
-ResolveHandler<Proto>::ResolveHandler(const std::string& addr, const std::string& port, boost::function<void(boost::asio::ip::basic_
endpoint<Proto>)> const& onResolve, ErrorCallback const& onError, ResolvAddrType r) : addr_(addr), port_(port), onResolve_(onResolve), onError_(onError), resolv_addr_type_(r)
+ResolveHandler<Proto>::ResolveHandler(const std::string& addr, const std::string& port, boost::function<void(boost::asio::ip::basic_
resolver_iterator<Proto>)> const& onResolve, ErrorCallback const& onError, ResolvAddrType r) : addr_(addr), port_(port), onResolve_(onResolve), onError_(onError), resolv_addr_type_(r)
{
}
template<class Proto>
-void ResolveHandler<Proto>::operator()(const boost::system::error_code& e,
const boost::asio::ip::basic_resolver_iterator<Proto> endpointIt)
+void ResolveHandler<Proto>::operator()(const boost::system::error_code& e, boost::asio::ip::basic_resolver_iterator<Proto> endpointIt)
{
if(boost::system::posix_error::success == e) {
try {
- onResolve_(*endpointIt);
- }
- catch(const std::runtime_error& e)
- {
+ onResolve_(endpointIt);
+ } catch(const std::runtime_error& e) {
onError_(e);
}
} else {
}
}
-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;
+ static Resolver instance;
+ return instance;
}
Resolver::Resolver() : udp_resolver_(io_service_), tcp_resolver_(io_service_), thread_(NULL)
Resolver::~Resolver()
{
- if(thread_)
+ if(thread_) {
delete thread_;
+ }
}
void Resolver::init()
{
- if(!thread_)
- thread_ = new boost::thread(boost::bind(&Resolver::run, this));
+ if(!thread_) {
+ thread_ = new boost::thread(boost::bind(&Resolver::run, this));
+ }
}
void Resolver::run()
{
cLog.msg(Log::PRIO_DEBUG) << "Resolver Thread started";
- while(1) {
+ for(;;) {
try {
io_service_.run();
io_service_.reset();
boost::this_thread::sleep(boost::posix_time::milliseconds(250));
- }
- catch(const std::runtime_error& e)
- {
+ } catch(const std::runtime_error& e) {
cLog.msg(Log::PRIO_ERROR) << "resolver caught runtime error, restarting: " << e.what();
- }
- catch(const std::exception& e)
- {
+ } catch(const std::exception& e) {
cLog.msg(Log::PRIO_ERROR) << "resolver caught exception, restarting: " << e.what();
}
}
{
cLog.msg(Log::PRIO_DEBUG) << "trying to resolv UDP: '" << addr << "' '" << port << "'";
- std::auto_ptr<udp::resolver::query> query;
+ boost::shared_ptr<udp::resolver::query> query;
if(addr != "") {
switch(r) {
- case IPV4_ONLY: query = std::auto_ptr<udp::resolver::query>(new udp::resolver::query(udp::v4(), addr, port)); break;
- case IPV6_ONLY: query = std::auto_ptr<udp::resolver::query>(new udp::resolver::query(udp::v6(), addr, port)); break;
- default: query = std::auto_ptr<udp::resolver::query>(new udp::resolver::query(addr, port)); break;
+ case IPV4_ONLY:
+ query = boost::shared_ptr<udp::resolver::query>(new udp::resolver::query(udp::v4(), addr, port));
+ break;
+ case IPV6_ONLY:
+ query = boost::shared_ptr<udp::resolver::query>(new udp::resolver::query(udp::v6(), addr, port));
+ break;
+ default:
+ query = boost::shared_ptr<udp::resolver::query>(new udp::resolver::query(addr, port));
+ break;
}
- }
- else {
+ } else {
switch(r) {
- case IPV4_ONLY: query = std::auto_ptr<udp::resolver::query>(new udp::resolver::query(udp::v4(), port)); break;
- case IPV6_ONLY: query = std::auto_ptr<udp::resolver::query>(new udp::resolver::query(udp::v6(), port)); break;
- default: query = std::auto_ptr<udp::resolver::query>(new udp::resolver::query(port)); break;
+ case IPV4_ONLY:
+ query = boost::shared_ptr<udp::resolver::query>(new udp::resolver::query(udp::v4(), port));
+ break;
+ case IPV6_ONLY:
+ query = boost::shared_ptr<udp::resolver::query>(new udp::resolver::query(udp::v6(), port));
+ break;
+ default:
+ query = boost::shared_ptr<udp::resolver::query>(new udp::resolver::query(port));
+ break;
}
}
UdpResolveHandler handler(addr, port, onResolve, onError, r);
{
cLog.msg(Log::PRIO_DEBUG) << "trying to resolv TCP: '" << addr << "' '" << port << "'";
- std::auto_ptr<tcp::resolver::query> query;
+ boost::shared_ptr<tcp::resolver::query> query;
if(addr != "") {
switch(r) {
- case IPV4_ONLY: query = std::auto_ptr<tcp::resolver::query>(new tcp::resolver::query(tcp::v4(), addr, port)); break;
- case IPV6_ONLY: query = std::auto_ptr<tcp::resolver::query>(new tcp::resolver::query(tcp::v6(), addr, port)); break;
- default: query = std::auto_ptr<tcp::resolver::query>(new tcp::resolver::query(addr, port)); break;
+ case IPV4_ONLY:
+ query = boost::shared_ptr<tcp::resolver::query>(new tcp::resolver::query(tcp::v4(), addr, port));
+ break;
+ case IPV6_ONLY:
+ query = boost::shared_ptr<tcp::resolver::query>(new tcp::resolver::query(tcp::v6(), addr, port));
+ break;
+ default:
+ query = boost::shared_ptr<tcp::resolver::query>(new tcp::resolver::query(addr, port));
+ break;
}
- }
- else {
+ } else {
switch(r) {
- case IPV4_ONLY: query = std::auto_ptr<tcp::resolver::query>(new tcp::resolver::query(tcp::v4(), port)); break;
- case IPV6_ONLY: query = std::auto_ptr<tcp::resolver::query>(new tcp::resolver::query(tcp::v6(), port)); break;
- default: query = std::auto_ptr<tcp::resolver::query>(new tcp::resolver::query(port)); break;
+ case IPV4_ONLY:
+ query = boost::shared_ptr<tcp::resolver::query>(new tcp::resolver::query(tcp::v4(), port));
+ break;
+ case IPV6_ONLY:
+ query = boost::shared_ptr<tcp::resolver::query>(new tcp::resolver::query(tcp::v6(), port));
+ break;
+ default:
+ query = boost::shared_ptr<tcp::resolver::query>(new tcp::resolver::query(port));
+ break;
}
}
TcpResolveHandler handler(addr, port, onResolve, onError, r);
- tcp_resolver_.async_resolve(*query, handler);
+ tcp_resolver_.async_resolve(*query, handler);
}
projects / anytun.git / blobdiff