[1784] (unrelated) editorial cleanup: space related, indentation, etc.

also fixed memory leak in a test case using scoped_ptr.

src/bin/auth/auth_srv.cc

@@ -310,7 +310,7 @@ makeErrorMessage(Message& message, OutputBuffer& buffer,
     for_each(questions.begin(), questions.end(), QuestionInserter(message));
 
     message.setRcode(rcode);
-    
+
     MessageRenderer renderer;
     renderer.setBuffer(&buffer);
     if (tsig_context.get() != NULL) {

src/bin/auth/tests/auth_srv_unittest.cc

@@ -1079,10 +1079,11 @@ TEST_F(AuthSrvTest, processNormalQuery_reuseRenderer1) {
     UnitTestUtil::createRequestMessage(request_message, Opcode::QUERY(),
                                        default_qid, Name("example.com"),
                                        RRClass::IN(), RRType::NS());
-    
+
     request_message.setHeaderFlag(Message::HEADERFLAG_AA);
     createRequestPacket(request_message, IPPROTO_UDP);
-    server.processMessage(*io_message, *parse_message, *response_obuffer, &dnsserv);
+    server.processMessage(*io_message, *parse_message, *response_obuffer,
+                          &dnsserv);
     EXPECT_NE(request_message.getRcode(), parse_message->getRcode());
 }
 
@@ -1090,12 +1091,14 @@ TEST_F(AuthSrvTest, processNormalQuery_reuseRenderer2) {
     UnitTestUtil::createRequestMessage(request_message, Opcode::QUERY(),
                                        default_qid, Name("example.com"),
                                        RRClass::IN(), RRType::SOA());
-    
+
     request_message.setHeaderFlag(Message::HEADERFLAG_AA);
     createRequestPacket(request_message, IPPROTO_UDP);
-    server.processMessage(*io_message, *parse_message, *response_obuffer, &dnsserv);
+    server.processMessage(*io_message, *parse_message, *response_obuffer,
+                          &dnsserv);
     ConstQuestionPtr question = *parse_message->beginQuestion();
-    EXPECT_STRNE(question->getType().toText().c_str(),RRType::NS().toText().c_str());
+    EXPECT_STRNE(question->getType().toText().c_str(),
+                 RRType::NS().toText().c_str());
 }
 //
 // Tests for catching exceptions in various stages of the query processing

src/lib/asiodns/dns_service.cc

@@ -88,37 +88,44 @@ public:
     }
 
     void addServer(uint16_t port, const asio::ip::address& address,
-                   const UDPVersion param_flags) {
+                   const UDPVersion param_flags)
+    {
         try {
-            dlog(std::string("Initialize TCP server at ") + address.to_string() + ":" + boost::lexical_cast<std::string>(port));
+            dlog(std::string("Initialize TCP server at ") +
+                 address.to_string() + ":" +
+                 boost::lexical_cast<std::string>(port));
             TCPServerPtr tcpServer(new TCPServer(io_service_.get_io_service(),
-                address, port, checkin_, lookup_, answer_));
+                                                 address, port, checkin_,
+                                                 lookup_, answer_));
             (*tcpServer)();
             servers_.push_back(tcpServer);
-            dlog(std::string("Initialize UDP server at ") + address.to_string() + ":" + boost::lexical_cast<std::string>(port));
-            // Use param_flags to generate diff UDPServers.    
-            switch(param_flags) {
-                case SYNC_: {
-                    SyncUDPServerPtr syncUdpServer(new SyncUDPServer(io_service_.get_io_service(),
-                                                   address, port, checkin_, lookup_, answer_));
-                    (*syncUdpServer)();
-                    servers_.push_back(syncUdpServer);
-                    break;
-                }
-                case ASYNC_: {
-                    UDPServerPtr udpServer(new UDPServer(io_service_.get_io_service(),
-                                           address, port, checkin_, lookup_, answer_));
-                    (*udpServer)();
-                    servers_.push_back(udpServer);
-                    break;
-                }
-                default:
-                    // If nerther asyn UDPServer nor sync UDNServer, it throws.
-                    isc_throw(IOError, "Bad UDPServer Version!");
-                    break;
+            dlog(std::string("Initialize UDP server at ") +
+                 address.to_string() + ":" +
+                 boost::lexical_cast<std::string>(port));
+            // Use param_flags to generate diff UDPServers.
+            switch (param_flags) {
+            case SYNC_: {
+                SyncUDPServerPtr syncUdpServer(
+                    new SyncUDPServer(io_service_.get_io_service(), address,
+                                      port, checkin_, lookup_, answer_));
+                (*syncUdpServer)();
+                servers_.push_back(syncUdpServer);
+                break;
             }
-        }
-        catch (const asio::system_error& err) {
+            case ASYNC_: {
+                UDPServerPtr udpServer(
+                    new UDPServer(io_service_.get_io_service(), address, port,
+                                  checkin_, lookup_, answer_));
+                (*udpServer)();
+                servers_.push_back(udpServer);
+                break;
+            }
+            default:
+                // If neither async UDPServer nor sync UDNServer, it throws.
+                isc_throw(IOError, "Bad UDPServer Version!");
+                break;
+            }
+        } catch (const asio::system_error& err) {
             // We need to catch and convert any ASIO level exceptions.
             // This can happen for unavailable address, binding a privilege port
             // without the privilege, etc.
@@ -127,7 +134,8 @@ public:
         }
     }
     void addServer(const char& port, const asio::ip::address& address,
-                   const UDPVersion param_flags) {
+                   const UDPVersion param_flags)
+    {
         uint16_t portnum;
         try {
             // XXX: SunStudio with stlport4 doesn't reject some invalid
@@ -143,7 +151,7 @@ public:
             isc_throw(IOError, "Invalid port number '" << &port << "': " <<
                       ex.what());
         }
-        addServer(portnum, address,param_flags);
+        addServer(portnum, address, param_flags);
     }
 };
 
@@ -162,10 +170,10 @@ DNSServiceImpl::DNSServiceImpl(IOService& io_service,
 {
 
     if (v4addr) {
-        addServer(port, *v4addr,param_flags);
+        addServer(port, *v4addr, param_flags);
     }
     if (v6addr) {
-        addServer(port, *v6addr,param_flags);
+        addServer(port, *v6addr, param_flags);
     }
 }
 
@@ -178,7 +186,7 @@ DNSService::DNSService(IOService& io_service,
     impl_(new DNSServiceImpl(io_service, port, NULL, NULL, checkin, lookup,
         answer,param_flags)), io_service_(io_service)
 {
-    addServer(port, &address,param_flags);
+    addServer(port, &address, param_flags);
 }
 
 DNSService::DNSService(IOService& io_service,
@@ -196,13 +204,14 @@ DNSService::DNSService(IOService& io_service,
     const asio::ip::address v6addr_any =
         asio::ip::address(asio::ip::address_v6::any());
     const asio::ip::address* const v6addrp = use_ipv6 ? &v6addr_any : NULL;
-    impl_ = new DNSServiceImpl(io_service, port, v4addrp, v6addrp, checkin, lookup, answer,param_flags);
+    impl_ = new DNSServiceImpl(io_service, port, v4addrp, v6addrp, checkin,
+                               lookup, answer, param_flags);
 }
 
 DNSService::DNSService(IOService& io_service, SimpleCallback* checkin,
     DNSLookup* lookup, DNSAnswer *answer,const UDPVersion param_flags) :
     impl_(new DNSServiceImpl(io_service, *"0", NULL, NULL, checkin, lookup,
-        answer,param_flags)), io_service_(io_service)
+        answer, param_flags)), io_service_(io_service)
 {
 }
 
@@ -211,24 +220,32 @@ DNSService::~DNSService() {
 }
 
 void
-DNSService::addServer(const char& port, const std::string& address,UDPVersion param_flags) {
-    impl_->addServer(port, convertAddr(address),param_flags);
+DNSService::addServer(const char& port, const std::string& address,
+                      UDPVersion param_flags)
+{
+    impl_->addServer(port, convertAddr(address), param_flags);
 }
 
 void
-DNSService::addServer(uint16_t port, const std::string& address,UDPVersion param_flags) {
-    impl_->addServer(port, convertAddr(address),param_flags);
+DNSService::addServer(uint16_t port, const std::string& address,
+                      UDPVersion param_flags)
+{
+    impl_->addServer(port, convertAddr(address), param_flags);
 }
 
 void DNSService::addServerTCPFromFD(int fd, int af) {
     impl_->addServerFromFD<DNSServiceImpl::TCPServerPtr, TCPServer>(fd, af);
 }
 
-void DNSService::addServerUDPFromFD(int fd, int af,const UDPVersion param_flags) {
-    if(SYNC_ == param_flags) { 
-        impl_->addServerFromFD<DNSServiceImpl::SyncUDPServerPtr, SyncUDPServer>(fd, af);
-    } else if(ASYNC_ == param_flags) {
-        impl_->addServerFromFD<DNSServiceImpl::UDPServerPtr, UDPServer>(fd, af);
+void DNSService::addServerUDPFromFD(int fd, int af,
+                                    const UDPVersion param_flags)
+{
+    if (SYNC_ == param_flags) {
+        impl_->addServerFromFD<DNSServiceImpl::SyncUDPServerPtr,
+            SyncUDPServer>(fd, af);
+    } else if (ASYNC_ == param_flags) {
+        impl_->addServerFromFD<DNSServiceImpl::UDPServerPtr, UDPServer>(
+            fd, af);
     }
 }
 

src/lib/asiodns/tests/io_service_unittest.cc

@@ -19,8 +19,11 @@
 #include <asiolink/asiolink.h>
 #include <asiodns/asiodns.h>
 
+#include <boost/scoped_ptr.hpp>
+
 using namespace isc::asiolink;
 using namespace isc::asiodns;
+using boost::scoped_ptr;
 
 const char* const TEST_SERVER_PORT = "53535";
 const char* const TEST_CLIENT_PORT = "53536";
@@ -118,6 +121,8 @@ TEST(IOServiceTest, DISABLED_IPv4MappedDuplicateBind) {
 
 TEST(IOServiceTest, BadUdpServerVersion) {
     IOService io_service;
-    DNSService* dns_service = new DNSService(io_service, NULL, NULL, NULL);
-    EXPECT_THROW(dns_service->addServer(*TEST_SERVER_PORT, "127.0.0.1", UDPVersion(3)), IOError);
+    scoped_ptr<DNSService> dns_service(new DNSService(io_service, NULL, NULL,
+                                                      NULL));
+    EXPECT_THROW(dns_service->addServer(*TEST_SERVER_PORT, "127.0.0.1",
+                                        UDPVersion(3)), IOError);
 }