Merge branch 'master' into random-webseeding

1 files changed, 64 insertions, 63 deletions

diff --git a/src/KqueueEventPoll.cc b/src/KqueueEventPoll.cc
index b5eff1d0..dc131fef 100644
--- a/src/KqueueEventPoll.cc
+++ b/src/KqueueEventPoll.cc
@@ -46,93 +46,92 @@
 #include "fmt.h"
 
 #ifdef KEVENT_UDATA_INTPTR_T
-# define PTR_TO_UDATA(X) (reinterpret_cast<intptr_t>(X))
+#define PTR_TO_UDATA(X) (reinterpret_cast<intptr_t>(X))
 #else // !KEVENT_UDATA_INTPTR_T
-# define PTR_TO_UDATA(X) (X)
+#define PTR_TO_UDATA(X) (X)
 #endif // !KEVENT_UDATA_INTPTR_T
 
 namespace aria2 {
 
 KqueueEventPoll::KSocketEntry::KSocketEntry(sock_t s)
-  : SocketEntry<KCommandEvent, KADNSEvent>(s)
-{}
+    : SocketEntry<KCommandEvent, KADNSEvent>(s)
+{
+}
 
 int accumulateEvent(int events, const KqueueEventPoll::KEvent& event)
 {
-  return events|event.getEvents();
+  return events | event.getEvents();
 }
 
-size_t KqueueEventPoll::KSocketEntry::getEvents
-(struct kevent* eventlist)
+size_t KqueueEventPoll::KSocketEntry::getEvents(struct kevent* eventlist)
 {
   int events;
 #ifdef ENABLE_ASYNC_DNS
   events =
-    std::accumulate(adnsEvents_.begin(),
-                    adnsEvents_.end(),
-                    std::accumulate(commandEvents_.begin(),
-                                    commandEvents_.end(), 0, accumulateEvent),
-                    accumulateEvent);
-#else // !ENABLE_ASYNC_DNS
-  events =
-    std::accumulate(commandEvents_.begin(), commandEvents_.end(), 0,
-                    accumulateEvent);
+      std::accumulate(adnsEvents_.begin(), adnsEvents_.end(),
+                      std::accumulate(commandEvents_.begin(),
+                                      commandEvents_.end(), 0, accumulateEvent),
+                      accumulateEvent);
+#else  // !ENABLE_ASYNC_DNS
+  events = std::accumulate(commandEvents_.begin(), commandEvents_.end(), 0,
+                           accumulateEvent);
 #endif // !ENABLE_ASYNC_DNS
   EV_SET(&eventlist[0], socket_, EVFILT_READ,
-         EV_ADD|((events&KqueueEventPoll::IEV_READ)?EV_ENABLE:EV_DISABLE),
+         EV_ADD |
+             ((events & KqueueEventPoll::IEV_READ) ? EV_ENABLE : EV_DISABLE),
          0, 0, PTR_TO_UDATA(this));
   EV_SET(&eventlist[1], socket_, EVFILT_WRITE,
-         EV_ADD|((events&KqueueEventPoll::IEV_WRITE)?EV_ENABLE:EV_DISABLE),
+         EV_ADD |
+             ((events & KqueueEventPoll::IEV_WRITE) ? EV_ENABLE : EV_DISABLE),
          0, 0, PTR_TO_UDATA(this));
   return 2;
 }
 
 KqueueEventPoll::KqueueEventPoll()
-  : kqEventsSize_(KQUEUE_EVENTS_MAX),
-    kqEvents_(make_unique<struct kevent[]>(kqEventsSize_))
+    : kqEventsSize_(KQUEUE_EVENTS_MAX),
+      kqEvents_(make_unique<struct kevent[]>(kqEventsSize_))
 {
   kqfd_ = kqueue();
 }
 
 KqueueEventPoll::~KqueueEventPoll()
 {
-  if(kqfd_ != -1) {
+  if (kqfd_ != -1) {
     int r = close(kqfd_);
     int errNum = errno;
-    if(r == -1) {
+    if (r == -1) {
       A2_LOG_ERROR(fmt("Error occurred while closing kqueue file descriptor"
                        " %d: %s",
-                       kqfd_,
-                       util::safeStrerror(errNum).c_str()));
+                       kqfd_, util::safeStrerror(errNum).c_str()));
     }
   }
 }
 
-bool KqueueEventPoll::good() const
-{
-  return kqfd_ != -1;
-}
+bool KqueueEventPoll::good() const { return kqfd_ != -1; }
 
 void KqueueEventPoll::poll(const struct timeval& tv)
 {
-  struct timespec timeout = { tv.tv_sec, tv.tv_usec*1000 };
+  struct timespec timeout = {tv.tv_sec, tv.tv_usec * 1000};
   int res;
-  while((res = kevent(kqfd_, kqEvents_.get(), 0, kqEvents_.get(),
-                      kqEventsSize_, &timeout))
-        == -1 && errno == EINTR);
-  if(res > 0) {
-    for(int i = 0; i < res; ++i) {
+  while ((res = kevent(kqfd_, kqEvents_.get(), 0, kqEvents_.get(),
+                       kqEventsSize_, &timeout)) == -1 &&
+         errno == EINTR)
+    ;
+  if (res > 0) {
+    for (int i = 0; i < res; ++i) {
       KSocketEntry* p = reinterpret_cast<KSocketEntry*>(kqEvents_[i].udata);
       int events = 0;
       int filter = kqEvents_[i].filter;
-      if(filter == EVFILT_READ) {
+      if (filter == EVFILT_READ) {
         events = KqueueEventPoll::IEV_READ;
-      } else if(filter == EVFILT_WRITE) {
+      }
+      else if (filter == EVFILT_WRITE) {
         events = KqueueEventPoll::IEV_WRITE;
       }
       p->processEvents(events);
     }
-  } else if(res == -1) {
+  }
+  else if (res == -1) {
     int errNum = errno;
     A2_LOG_INFO(fmt("kevent error: %s", util::safeStrerror(errNum).c_str()));
   }
@@ -141,7 +140,7 @@ void KqueueEventPoll::poll(const struct timeval& tv)
   // own timeout and ares may create new sockets or closes socket in
   // their API. So we call ares_process_fd for all ares_channel and
   // re-register their sockets.
-  for(auto & r : nameResolverEntries_) {
+  for (auto& r : nameResolverEntries_) {
     auto& ent = r.second;
     ent.processTimeout();
     ent.removeSocketEvents(this);
@@ -157,32 +156,33 @@ namespace {
 int translateEvents(EventPoll::EventType events)
 {
   int newEvents = 0;
-  if(EventPoll::EVENT_READ&events) {
+  if (EventPoll::EVENT_READ & events) {
     newEvents |= KqueueEventPoll::IEV_READ;
   }
-  if(EventPoll::EVENT_WRITE&events) {
+  if (EventPoll::EVENT_WRITE & events) {
     newEvents |= KqueueEventPoll::IEV_WRITE;
   }
   return newEvents;
 }
 } // namespace
 
-bool KqueueEventPoll::addEvents
-(sock_t socket, const KqueueEventPoll::KEvent& event)
+bool KqueueEventPoll::addEvents(sock_t socket,
+                                const KqueueEventPoll::KEvent& event)
 {
   auto i = socketEntries_.lower_bound(socket);
   int r = 0;
-  struct timespec zeroTimeout = { 0, 0 };
+  struct timespec zeroTimeout = {0, 0};
   struct kevent changelist[2];
   size_t n;
-  if(i != std::end(socketEntries_) && (*i).first == socket) {
+  if (i != std::end(socketEntries_) && (*i).first == socket) {
     auto& socketEntry = (*i).second;
     event.addSelf(&socketEntry);
     n = socketEntry.getEvents(changelist);
-  } else {
+  }
+  else {
     i = socketEntries_.insert(i, std::make_pair(socket, KSocketEntry(socket)));
     auto& socketEntry = (*i).second;
-    if(socketEntries_.size() > kqEventsSize_) {
+    if (socketEntries_.size() > kqEventsSize_) {
       kqEventsSize_ *= 2;
       kqEvents_ = make_unique<struct kevent[]>(kqEventsSize_);
     }
@@ -191,12 +191,12 @@ bool KqueueEventPoll::addEvents
   }
   r = kevent(kqfd_, changelist, n, changelist, 0, &zeroTimeout);
   int errNum = errno;
-  if(r == -1) {
-    A2_LOG_DEBUG(fmt("Failed to add socket event %d:%s",
-                     socket,
+  if (r == -1) {
+    A2_LOG_DEBUG(fmt("Failed to add socket event %d:%s", socket,
                      util::safeStrerror(errNum).c_str()));
     return false;
-  } else {
+  }
+  else {
     return true;
   }
 }
@@ -220,7 +220,7 @@ bool KqueueEventPoll::deleteEvents(sock_t socket,
                                    const KqueueEventPoll::KEvent& event)
 {
   auto i = socketEntries_.find(socket);
-  if(i == std::end(socketEntries_)) {
+  if (i == std::end(socketEntries_)) {
     A2_LOG_DEBUG(fmt("Socket %d is not found in SocketEntries.", socket));
     return false;
   }
@@ -228,19 +228,20 @@ bool KqueueEventPoll::deleteEvents(sock_t socket,
   auto& socketEntry = (*i).second;
   event.removeSelf(&socketEntry);
   int r = 0;
-  struct timespec zeroTimeout = { 0, 0 };
+  struct timespec zeroTimeout = {0, 0};
   struct kevent changelist[2];
   size_t n = socketEntry.getEvents(changelist);
   r = kevent(kqfd_, changelist, n, changelist, 0, &zeroTimeout);
   int errNum = errno;
-  if(socketEntry.eventEmpty()) {
+  if (socketEntry.eventEmpty()) {
     socketEntries_.erase(i);
   }
-  if(r == -1) {
+  if (r == -1) {
     A2_LOG_DEBUG(fmt("Failed to delete socket event:%s",
                      util::safeStrerror(errNum).c_str()));
     return false;
-  } else {
+  }
+  else {
     return true;
   }
 }
@@ -261,28 +262,28 @@ bool KqueueEventPoll::deleteEvents(sock_t socket, Command* command,
 }
 
 #ifdef ENABLE_ASYNC_DNS
-bool KqueueEventPoll::addNameResolver
-(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
+bool KqueueEventPoll::addNameResolver(
+    const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
   auto key = std::make_pair(resolver.get(), command);
   auto itr = nameResolverEntries_.lower_bound(key);
 
-  if(itr != std::end(nameResolverEntries_) && (*itr).first == key) {
+  if (itr != std::end(nameResolverEntries_) && (*itr).first == key) {
     return false;
   }
 
-  itr = nameResolverEntries_.insert
-    (itr, std::make_pair(key, KAsyncNameResolverEntry(resolver, command)));
+  itr = nameResolverEntries_.insert(
+      itr, std::make_pair(key, KAsyncNameResolverEntry(resolver, command)));
   (*itr).second.addSocketEvents(this);
   return true;
 }
 
-bool KqueueEventPoll::deleteNameResolver
-(const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
+bool KqueueEventPoll::deleteNameResolver(
+    const std::shared_ptr<AsyncNameResolver>& resolver, Command* command)
 {
   auto key = std::make_pair(resolver.get(), command);
   auto itr = nameResolverEntries_.find(key);
-  if(itr == std::end(nameResolverEntries_)) {
+  if (itr == std::end(nameResolverEntries_)) {
     return false;
   }