X-Git-Url: https://git.syn-net.org/debian/?a=blobdiff_plain;f=src%2Fresolver.cpp;h=6a17cde19ea67859d78f0be03e09f24b40a18237;hb=bd02a5f6be4815d46524d613f727199ca756c971;hp=66f1e7eced8085fc290da0143be69d8f7e737ceb;hpb=f9ad69dfae6bcec427652b0c4230603e465bd544;p=anytun.git

diff --git a/src/resolver.cpp b/src/resolver.cpp
index 66f1e7e..6a17cde 100644
--- a/src/resolver.cpp
+++ b/src/resolver.cpp
@@ -11,7 +11,7 @@
  *  tunneling and relaying of packets of any protocol.
  *
  *
- *  Copyright (C) 2007-2009 Othmar Gsenger, Erwin Nindl, 
+ *  Copyright (C) 2007-2009 Othmar Gsenger, Erwin Nindl,
  *                          Christian Pointner <satp@wirdorange.org>
  *
  *  This file is part of Anytun.
@@ -40,20 +40,20 @@ using ::boost::asio::ip::udp;
 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(uint32_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);
@@ -61,19 +61,17 @@ void waitAndEnqueue(u_int32_t s, const std::string& addr, const std::string& por
 
 
 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 {
@@ -90,9 +88,10 @@ Resolver& Resolver::instance()
 {
   Lock lock(instMutex);
   static instanceCleaner c;
-  if(!inst)
+  if(!inst) {
     inst = new Resolver();
-  
+  }
+
   return *inst;
 }
 
@@ -102,14 +101,16 @@ Resolver::Resolver() : udp_resolver_(io_service_), tcp_resolver_(io_service_), t
 
 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()
@@ -121,13 +122,9 @@ void Resolver::run()
       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();
     }
   }
@@ -141,16 +138,27 @@ void Resolver::resolveUdp(const std::string& addr, const std::string& port, UdpR
   std::auto_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 = 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;
     }
-  }
-  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 = 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;
     }
   }
   UdpResolveHandler handler(addr, port, onResolve, onError, r);
@@ -164,18 +172,29 @@ void Resolver::resolveTcp(const std::string& addr, const std::string& port, TcpR
   std::auto_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 = 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;
     }
-  }
-  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 = 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;
     }
   }
   TcpResolveHandler handler(addr, port, onResolve, onError, r);
-  tcp_resolver_.async_resolve(*query, handler); 
+  tcp_resolver_.async_resolve(*query, handler);
 }