New upstream version 2.4.0upstream/2.4.0

1 files changed, 813 insertions, 690 deletions

diff --git a/src/openvpn/event.c b/src/openvpn/event.c
index 409ad13..f4922e0 100644
--- a/src/openvpn/event.c
+++ b/src/openvpn/event.c
@@ -5,7 +5,7 @@
  *             packet encryption, packet authentication, and
  *             packet compression.
  *
- *  Copyright (C) 2002-2010 OpenVPN Technologies, Inc. <sales@openvpn.net>
+ *  Copyright (C) 2002-2017 OpenVPN Technologies, Inc. <sales@openvpn.net>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2
@@ -66,400 +66,453 @@
 #endif
 
 static inline int
-tv_to_ms_timeout (const struct timeval *tv)
+tv_to_ms_timeout(const struct timeval *tv)
 {
-  if (tv->tv_sec == 0 && tv->tv_usec == 0)
-    return 0;
-  else
-    return max_int (tv->tv_sec * 1000 + (tv->tv_usec + 500) / 1000, 1);
+    if (tv->tv_sec == 0 && tv->tv_usec == 0)
+    {
+        return 0;
+    }
+    else
+    {
+        return max_int(tv->tv_sec * 1000 + (tv->tv_usec + 500) / 1000, 1);
+    }
 }
 
 #ifdef _WIN32
 
 struct we_set
 {
-  struct event_set_functions func;
-  bool fast;
-  HANDLE *events;
-  struct event_set_return *esr;
-  int n_events;
-  int capacity;
+    struct event_set_functions func;
+    bool fast;
+    HANDLE *events;
+    struct event_set_return *esr;
+    int n_events;
+    int capacity;
 };
 
 static inline void
-we_set_event (struct we_set *wes, int i, event_t event, unsigned int rwflags, void *arg)
+we_set_event(struct we_set *wes, int i, event_t event, unsigned int rwflags, void *arg)
 {
-  ASSERT (i >= 0 && i < wes->capacity);
+    ASSERT(i >= 0 && i < wes->capacity);
 
-  if (rwflags == EVENT_READ)
+    if (rwflags == EVENT_READ)
     {
-      ASSERT (event->read != NULL);
-      wes->events[i] = event->read;
+        ASSERT(event->read != NULL);
+        wes->events[i] = event->read;
     }
-  else if (rwflags == EVENT_WRITE)
+    else if (rwflags == EVENT_WRITE)
     {
-      ASSERT (event->write != NULL);
-      wes->events[i] = event->write;
+        ASSERT(event->write != NULL);
+        wes->events[i] = event->write;
     }
-  else
-    msg (M_FATAL, "fatal error in we_set_events: rwflags=%d", rwflags);
-      
-  wes->esr[i].rwflags = rwflags;
-  wes->esr[i].arg = arg;
+    else
+    {
+        msg(M_FATAL, "fatal error in we_set_events: rwflags=%d", rwflags);
+    }
+
+    wes->esr[i].rwflags = rwflags;
+    wes->esr[i].arg = arg;
 }
 
 static inline bool
-we_append_event (struct we_set *wes, event_t event, unsigned int rwflags, void *arg)
+we_append_event(struct we_set *wes, event_t event, unsigned int rwflags, void *arg)
 {
-  if (rwflags & EVENT_WRITE)
+    if (rwflags & EVENT_WRITE)
     {
-      if (wes->n_events < wes->capacity)
-	{
-	  we_set_event (wes, wes->n_events, event, EVENT_WRITE, arg);
-	  ++wes->n_events;
-	}
-      else
-	return false;
+        if (wes->n_events < wes->capacity)
+        {
+            we_set_event(wes, wes->n_events, event, EVENT_WRITE, arg);
+            ++wes->n_events;
+        }
+        else
+        {
+            return false;
+        }
     }
-  if (rwflags & EVENT_READ)
+    if (rwflags & EVENT_READ)
     {
-      if (wes->n_events < wes->capacity)
-	{
-	  we_set_event (wes, wes->n_events, event, EVENT_READ, arg);
-	  ++wes->n_events;
-	}
-      else
-	return false;
+        if (wes->n_events < wes->capacity)
+        {
+            we_set_event(wes, wes->n_events, event, EVENT_READ, arg);
+            ++wes->n_events;
+        }
+        else
+        {
+            return false;
+        }
     }
-  return true;
+    return true;
 }
 
 static void
-we_del_event (struct we_set *wes, event_t event)
+we_del_event(struct we_set *wes, event_t event)
 {
-  int i, j = 0;
-  const int len = wes->n_events;
+    int i, j = 0;
+    const int len = wes->n_events;
 
-  for (i = 0; i < len; ++i)
+    for (i = 0; i < len; ++i)
     {
-      const HANDLE h = wes->events[i];
-      if (h == event->read || h == event->write)
-	--wes->n_events;
-      else
-	{
-	  if (i != j)
-	    {
-	      wes->events[j] = wes->events[i];
-	      wes->esr[j] = wes->esr[i];
-	    }
-	  ++j;
-	}
+        const HANDLE h = wes->events[i];
+        if (h == event->read || h == event->write)
+        {
+            --wes->n_events;
+        }
+        else
+        {
+            if (i != j)
+            {
+                wes->events[j] = wes->events[i];
+                wes->esr[j] = wes->esr[i];
+            }
+            ++j;
+        }
     }
 }
 
 static void
-we_del_index (struct we_set *wes, int index)
+we_del_index(struct we_set *wes, int index)
 {
-  int i;
-  ASSERT (index >= 0 && index < wes->n_events);
-  for (i = index; i < wes->n_events - 1; ++i)
+    int i;
+    ASSERT(index >= 0 && index < wes->n_events);
+    for (i = index; i < wes->n_events - 1; ++i)
     {
-      wes->events[i] = wes->events[i+1];
-      wes->esr[i] = wes->esr[i+1];
+        wes->events[i] = wes->events[i+1];
+        wes->esr[i] = wes->esr[i+1];
     }
-  --wes->n_events;
+    --wes->n_events;
 }
 
 static void
-we_get_rw_indices (struct we_set *wes, event_t event, int *ri, int *wi)
+we_get_rw_indices(struct we_set *wes, event_t event, int *ri, int *wi)
 {
-  int i;
-  *ri = *wi = -1;
-  for (i = 0; i < wes->n_events; ++i)
+    int i;
+    *ri = *wi = -1;
+    for (i = 0; i < wes->n_events; ++i)
     {
-      const HANDLE h = wes->events[i];
-      if (h == event->read)
-	{
-	  ASSERT (*ri == -1);
-	  *ri = i;
-	}
-      else if (h == event->write)
-	{
-	  ASSERT (*wi == -1);
-	  *wi = i;
-	}
+        const HANDLE h = wes->events[i];
+        if (h == event->read)
+        {
+            ASSERT(*ri == -1);
+            *ri = i;
+        }
+        else if (h == event->write)
+        {
+            ASSERT(*wi == -1);
+            *wi = i;
+        }
     }
 }
 
 static void
-we_free (struct event_set *es)
+we_free(struct event_set *es)
 {
-  struct we_set *wes = (struct we_set *) es;
-  free (wes->events);
-  free (wes->esr);
-  free (wes);
+    struct we_set *wes = (struct we_set *) es;
+    free(wes->events);
+    free(wes->esr);
+    free(wes);
 }
 
 static void
-we_reset (struct event_set *es)
+we_reset(struct event_set *es)
 {
-  struct we_set *wes = (struct we_set *) es;
-  ASSERT (wes->fast);
-  wes->n_events = 0;
+    struct we_set *wes = (struct we_set *) es;
+    ASSERT(wes->fast);
+    wes->n_events = 0;
 }
 
 static void
-we_del (struct event_set *es, event_t event)
+we_del(struct event_set *es, event_t event)
 {
-  struct we_set *wes = (struct we_set *) es;
-  ASSERT (!wes->fast);
-  we_del_event (wes, event);
+    struct we_set *wes = (struct we_set *) es;
+    ASSERT(!wes->fast);
+    we_del_event(wes, event);
 }
 
 static void
-we_ctl (struct event_set *es, event_t event, unsigned int rwflags, void *arg)
+we_ctl(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
 {
-  struct we_set *wes = (struct we_set *) es;
+    struct we_set *wes = (struct we_set *) es;
 
-  dmsg (D_EVENT_WAIT, "WE_CTL n=%d ev=%p rwflags=0x%04x arg=" ptr_format,
-       wes->n_events,
-       event,
-       rwflags,
-       (ptr_type)arg);
+    dmsg(D_EVENT_WAIT, "WE_CTL n=%d ev=%p rwflags=0x%04x arg=" ptr_format,
+         wes->n_events,
+         event,
+         rwflags,
+         (ptr_type)arg);
 
-  if (wes->fast)
+    if (wes->fast)
     {
-      if (!we_append_event (wes, event, rwflags, arg))
-	goto err;
+        if (!we_append_event(wes, event, rwflags, arg))
+        {
+            goto err;
+        }
     }
-  else
+    else
     {
-      int ri, wi;
-      int one = -1;
-      int n = 0;
-
-      we_get_rw_indices (wes, event, &ri, &wi);
-      if (wi >= 0)
-	{
-	  one = wi;
-	  ++n;
-	}
-      if (ri >= 0)
-	{
-	  one = ri;
-	  ++n;
-	}
-      switch (rwflags)
-	{
-	case 0:
-	  switch (n)
-	    {
-	    case 0:
-	      break;
-	    case 1:
-	      we_del_index (wes, one);
-	      break;
-	    case 2:
-	      we_del_event (wes, event);
-	      break;
-	    default:
-	      ASSERT (0);
-	    }
-	  break;
-	case EVENT_READ:
-	  switch (n)
-	    {
-	    case 0:
-	      if (!we_append_event (wes, event, EVENT_READ, arg))
-		goto err;
-	      break;
-	    case 1:
-	      we_set_event (wes, one, event, EVENT_READ, arg);
-	      break;
-	    case 2:
-	      we_del_index (wes, wi);
-	      break;
-	    default:
-	      ASSERT (0);
-	    }
-	  break;
-	case EVENT_WRITE:
-	  switch (n)
-	    {
-	    case 0:
-	      if (!we_append_event (wes, event, EVENT_WRITE, arg))
-		goto err;
-	      break;
-	    case 1:
-	      we_set_event (wes, one, event, EVENT_WRITE, arg);
-	      break;
-	    case 2:
-	      we_del_index (wes, ri);
-	      break;
-	    default:
-	      ASSERT (0);
-	    }
-	  break;
-	case EVENT_READ|EVENT_WRITE:
-	  switch (n)
-	    {
-	    case 0:
-	      if (!we_append_event (wes, event, EVENT_READ|EVENT_WRITE, arg))
-		goto err;
-	      break;
-	    case 1:
-	      if (ri == -1)
-		{
-		  ASSERT (wi != -1);
-		  if (!we_append_event (wes, event, EVENT_READ, arg))
-		    goto err;
-		}
-	      else if (wi == -1)
-		{
-		  if (!we_append_event (wes, event, EVENT_WRITE, arg))
-		    goto err;
-		}
-	      else
-		ASSERT (0);
-	      break;
-	    case 2:
-	      break;
-	    default:
-	      ASSERT (0);
-	    }
-	  break;
-	default:
-	  msg (M_FATAL, "fatal error in we_ctl: rwflags=%d", rwflags);
-	}
+        int ri, wi;
+        int one = -1;
+        int n = 0;
+
+        we_get_rw_indices(wes, event, &ri, &wi);
+        if (wi >= 0)
+        {
+            one = wi;
+            ++n;
+        }
+        if (ri >= 0)
+        {
+            one = ri;
+            ++n;
+        }
+        switch (rwflags)
+        {
+            case 0:
+                switch (n)
+                {
+                    case 0:
+                        break;
+
+                    case 1:
+                        we_del_index(wes, one);
+                        break;
+
+                    case 2:
+                        we_del_event(wes, event);
+                        break;
+
+                    default:
+                        ASSERT(0);
+                }
+                break;
+
+            case EVENT_READ:
+                switch (n)
+                {
+                    case 0:
+                        if (!we_append_event(wes, event, EVENT_READ, arg))
+                        {
+                            goto err;
+                        }
+                        break;
+
+                    case 1:
+                        we_set_event(wes, one, event, EVENT_READ, arg);
+                        break;
+
+                    case 2:
+                        we_del_index(wes, wi);
+                        break;
+
+                    default:
+                        ASSERT(0);
+                }
+                break;
+
+            case EVENT_WRITE:
+                switch (n)
+                {
+                    case 0:
+                        if (!we_append_event(wes, event, EVENT_WRITE, arg))
+                        {
+                            goto err;
+                        }
+                        break;
+
+                    case 1:
+                        we_set_event(wes, one, event, EVENT_WRITE, arg);
+                        break;
+
+                    case 2:
+                        we_del_index(wes, ri);
+                        break;
+
+                    default:
+                        ASSERT(0);
+                }
+                break;
+
+            case EVENT_READ|EVENT_WRITE:
+                switch (n)
+                {
+                    case 0:
+                        if (!we_append_event(wes, event, EVENT_READ|EVENT_WRITE, arg))
+                        {
+                            goto err;
+                        }
+                        break;
+
+                    case 1:
+                        if (ri == -1)
+                        {
+                            ASSERT(wi != -1);
+                            if (!we_append_event(wes, event, EVENT_READ, arg))
+                            {
+                                goto err;
+                            }
+                        }
+                        else if (wi == -1)
+                        {
+                            if (!we_append_event(wes, event, EVENT_WRITE, arg))
+                            {
+                                goto err;
+                            }
+                        }
+                        else
+                        {
+                            ASSERT(0);
+                        }
+                        break;
+
+                    case 2:
+                        break;
+
+                    default:
+                        ASSERT(0);
+                }
+                break;
+
+            default:
+                msg(M_FATAL, "fatal error in we_ctl: rwflags=%d", rwflags);
+        }
     }
-  return;
+    return;
 
- err:
-  msg (D_EVENT_ERRORS, "Error: Windows resource limit WSA_MAXIMUM_WAIT_EVENTS (%d) has been exceeded", WSA_MAXIMUM_WAIT_EVENTS);
+err:
+    msg(D_EVENT_ERRORS, "Error: Windows resource limit WSA_MAXIMUM_WAIT_EVENTS (%d) has been exceeded", WSA_MAXIMUM_WAIT_EVENTS);
 }
 
 static int
-we_wait (struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
+we_wait(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
 {
-  struct we_set *wes = (struct we_set *) es;
-  const int timeout = tv_to_ms_timeout (tv);
-  DWORD status;
+    struct we_set *wes = (struct we_set *) es;
+    const int timeout = tv_to_ms_timeout(tv);
+    DWORD status;
 
-  dmsg (D_EVENT_WAIT, "WE_WAIT enter n=%d to=%d", wes->n_events, timeout);
+    dmsg(D_EVENT_WAIT, "WE_WAIT enter n=%d to=%d", wes->n_events, timeout);
 
 #ifdef ENABLE_DEBUG
-  if (check_debug_level (D_EVENT_WAIT)) {
-    int i;
-    for (i = 0; i < wes->n_events; ++i)
-      dmsg (D_EVENT_WAIT, "[%d] ev=%p rwflags=0x%04x arg=" ptr_format,
-       i,
-       wes->events[i],
-       wes->esr[i].rwflags,
-       (ptr_type)wes->esr[i].arg);
-  }
+    if (check_debug_level(D_EVENT_WAIT))
+    {
+        int i;
+        for (i = 0; i < wes->n_events; ++i)
+            dmsg(D_EVENT_WAIT, "[%d] ev=%p rwflags=0x%04x arg=" ptr_format,
+                 i,
+                 wes->events[i],
+                 wes->esr[i].rwflags,
+                 (ptr_type)wes->esr[i].arg);
+    }
 #endif
 
-  /*
-   * First poll our event list with 0 timeout
-   */
-  status = WSAWaitForMultipleEvents(
-    (DWORD) wes->n_events,
-    wes->events,
-    FALSE,
-    (DWORD) 0,
-    FALSE);
-
-  /*
-   * If at least one event is already set, we must
-   * individually poll the whole list.
-   */
-  if (status >= WSA_WAIT_EVENT_0 && status < WSA_WAIT_EVENT_0 + (DWORD) wes->n_events)
+    /*
+     * First poll our event list with 0 timeout
+     */
+    status = WSAWaitForMultipleEvents(
+        (DWORD) wes->n_events,
+        wes->events,
+        FALSE,
+        (DWORD) 0,
+        FALSE);
+
+    /*
+     * If at least one event is already set, we must
+     * individually poll the whole list.
+     */
+    if (status >= WSA_WAIT_EVENT_0 && status < WSA_WAIT_EVENT_0 + (DWORD) wes->n_events)
     {
-      int i;
-      int j = 0;
-      for (i = 0; i < wes->n_events; ++i)
-	{
-	  if (j >= outlen)
-	    break;
-	  if (WaitForSingleObject (wes->events[i], 0) == WAIT_OBJECT_0)
-	    {
-	      *out = wes->esr[i];
-	      dmsg (D_EVENT_WAIT, "WE_WAIT leave [%d,%d] rwflags=0x%04x arg=" ptr_format,
-		   i, j, out->rwflags, (ptr_type)out->arg);
-	      ++j;
-	      ++out;
-	    }
-	}
-      return j;
+        int i;
+        int j = 0;
+        for (i = 0; i < wes->n_events; ++i)
+        {
+            if (j >= outlen)
+            {
+                break;
+            }
+            if (WaitForSingleObject(wes->events[i], 0) == WAIT_OBJECT_0)
+            {
+                *out = wes->esr[i];
+                dmsg(D_EVENT_WAIT, "WE_WAIT leave [%d,%d] rwflags=0x%04x arg=" ptr_format,
+                     i, j, out->rwflags, (ptr_type)out->arg);
+                ++j;
+                ++out;
+            }
+        }
+        return j;
     }
-  else
+    else
     {
-      /*
-       * If caller specified timeout > 0, we know at this point
-       * that no events are set, so wait only for the first event
-       * (or timeout) and return at most one event_set_return object.
-       *
-       * If caller specified timeout == 0, the second call to
-       * WSAWaitForMultipleEvents would be redundant -- just
-       * return 0 indicating timeout.
-       */
-      if (timeout > 0)
-	status = WSAWaitForMultipleEvents(
-	  (DWORD) wes->n_events,
-	  wes->events,
-	  FALSE,
-	  (DWORD) timeout,
-	  FALSE);
-  
-      if (outlen >= 1 && status >= WSA_WAIT_EVENT_0 && status < WSA_WAIT_EVENT_0 + (DWORD) wes->n_events)
-	{
-	  *out = wes->esr[status - WSA_WAIT_EVENT_0];
-	  dmsg (D_EVENT_WAIT, "WE_WAIT leave rwflags=0x%04x arg=" ptr_format,
-	       out->rwflags, (ptr_type)out->arg);
-	  return 1;
-	}
-      else if (status == WSA_WAIT_TIMEOUT)
-	return 0;
-      else
-	return -1;
+        /*
+         * If caller specified timeout > 0, we know at this point
+         * that no events are set, so wait only for the first event
+         * (or timeout) and return at most one event_set_return object.
+         *
+         * If caller specified timeout == 0, the second call to
+         * WSAWaitForMultipleEvents would be redundant -- just
+         * return 0 indicating timeout.
+         */
+        if (timeout > 0)
+        {
+            status = WSAWaitForMultipleEvents(
+                (DWORD) wes->n_events,
+                wes->events,
+                FALSE,
+                (DWORD) timeout,
+                FALSE);
+        }
+
+        if (outlen >= 1 && status >= WSA_WAIT_EVENT_0 && status < WSA_WAIT_EVENT_0 + (DWORD) wes->n_events)
+        {
+            *out = wes->esr[status - WSA_WAIT_EVENT_0];
+            dmsg(D_EVENT_WAIT, "WE_WAIT leave rwflags=0x%04x arg=" ptr_format,
+                 out->rwflags, (ptr_type)out->arg);
+            return 1;
+        }
+        else if (status == WSA_WAIT_TIMEOUT)
+        {
+            return 0;
+        }
+        else
+        {
+            return -1;
+        }
     }
 }
 
 static struct event_set *
-we_init (int *maxevents, unsigned int flags)
+we_init(int *maxevents, unsigned int flags)
 {
-  struct we_set *wes;
+    struct we_set *wes;
 
-  dmsg (D_EVENT_WAIT, "WE_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
+    dmsg(D_EVENT_WAIT, "WE_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
 
-  ALLOC_OBJ_CLEAR (wes, struct we_set);
+    ALLOC_OBJ_CLEAR(wes, struct we_set);
 
-  /* set dispatch functions */
-  wes->func.free = we_free;
-  wes->func.reset = we_reset;
-  wes->func.del = we_del;
-  wes->func.ctl = we_ctl;
-  wes->func.wait = we_wait;
+    /* set dispatch functions */
+    wes->func.free = we_free;
+    wes->func.reset = we_reset;
+    wes->func.del = we_del;
+    wes->func.ctl = we_ctl;
+    wes->func.wait = we_wait;
 
-  if (flags & EVENT_METHOD_FAST)
-    wes->fast = true;
-  wes->n_events = 0;
+    if (flags & EVENT_METHOD_FAST)
+    {
+        wes->fast = true;
+    }
+    wes->n_events = 0;
 
-  /* Figure our event capacity */
-  ASSERT (*maxevents > 0);
-  wes->capacity = min_int (*maxevents * 2, WSA_MAXIMUM_WAIT_EVENTS);
-  *maxevents = min_int (*maxevents, WSA_MAXIMUM_WAIT_EVENTS);
+    /* Figure our event capacity */
+    ASSERT(*maxevents > 0);
+    wes->capacity = min_int(*maxevents * 2, WSA_MAXIMUM_WAIT_EVENTS);
+    *maxevents = min_int(*maxevents, WSA_MAXIMUM_WAIT_EVENTS);
 
-  /* Allocate space for Win32 event handles */
-  ALLOC_ARRAY_CLEAR (wes->events, HANDLE, wes->capacity);
+    /* Allocate space for Win32 event handles */
+    ALLOC_ARRAY_CLEAR(wes->events, HANDLE, wes->capacity);
 
-  /* Allocate space for event_set_return objects */
-  ALLOC_ARRAY_CLEAR (wes->esr, struct event_set_return, wes->capacity);
+    /* Allocate space for event_set_return objects */
+    ALLOC_ARRAY_CLEAR(wes->esr, struct event_set_return, wes->capacity);
 
-  dmsg (D_EVENT_WAIT, "WE_INIT maxevents=%d capacity=%d",
-       *maxevents, wes->capacity);
+    dmsg(D_EVENT_WAIT, "WE_INIT maxevents=%d capacity=%d",
+         *maxevents, wes->capacity);
 
-  return (struct event_set *) wes;
+    return (struct event_set *) wes;
 }
 
 #endif /* _WIN32 */
@@ -468,145 +521,163 @@ we_init (int *maxevents, unsigned int flags)
 
 struct ep_set
 {
-  struct event_set_functions func;
-  bool fast;
-  int epfd;
-  int maxevents;
-  struct epoll_event *events;
+    struct event_set_functions func;
+    bool fast;
+    int epfd;
+    int maxevents;
+    struct epoll_event *events;
 };
 
 static void
-ep_free (struct event_set *es)
+ep_free(struct event_set *es)
 {
-  struct ep_set *eps = (struct ep_set *) es;
-  close (eps->epfd);
-  free (eps->events);
-  free (eps);
+    struct ep_set *eps = (struct ep_set *) es;
+    close(eps->epfd);
+    free(eps->events);
+    free(eps);
 }
 
 static void
-ep_reset (struct event_set *es)
+ep_reset(struct event_set *es)
 {
-  const struct ep_set *eps = (struct ep_set *) es;
-  ASSERT (eps->fast);
+    const struct ep_set *eps = (struct ep_set *) es;
+    ASSERT(eps->fast);
 }
 
 static void
-ep_del (struct event_set *es, event_t event)
+ep_del(struct event_set *es, event_t event)
 {
-  struct epoll_event ev;
-  struct ep_set *eps = (struct ep_set *) es;
+    struct epoll_event ev;
+    struct ep_set *eps = (struct ep_set *) es;
 
-  dmsg (D_EVENT_WAIT, "EP_DEL ev=%d", (int)event);
+    dmsg(D_EVENT_WAIT, "EP_DEL ev=%d", (int)event);
 
-  ASSERT (!eps->fast);
-  CLEAR (ev);
-  epoll_ctl (eps->epfd, EPOLL_CTL_DEL, event, &ev);
+    ASSERT(!eps->fast);
+    CLEAR(ev);
+    epoll_ctl(eps->epfd, EPOLL_CTL_DEL, event, &ev);
 }
 
 static void
-ep_ctl (struct event_set *es, event_t event, unsigned int rwflags, void *arg)
+ep_ctl(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
 {
-  struct ep_set *eps = (struct ep_set *) es;
-  struct epoll_event ev;
+    struct ep_set *eps = (struct ep_set *) es;
+    struct epoll_event ev;
 
-  CLEAR (ev);
+    CLEAR(ev);
 
-  ev.data.ptr = arg;
-  if (rwflags & EVENT_READ)
-    ev.events |= EPOLLIN;
-  if (rwflags & EVENT_WRITE)
-    ev.events |= EPOLLOUT;
+    ev.data.ptr = arg;
+    if (rwflags & EVENT_READ)
+    {
+        ev.events |= EPOLLIN;
+    }
+    if (rwflags & EVENT_WRITE)
+    {
+        ev.events |= EPOLLOUT;
+    }
 
-  dmsg (D_EVENT_WAIT, "EP_CTL fd=%d rwflags=0x%04x ev=0x%08x arg=" ptr_format,
-       (int)event,
-       rwflags,
-       (unsigned int)ev.events,
-       (ptr_type)ev.data.ptr);
+    dmsg(D_EVENT_WAIT, "EP_CTL fd=%d rwflags=0x%04x ev=0x%08x arg=" ptr_format,
+         (int)event,
+         rwflags,
+         (unsigned int)ev.events,
+         (ptr_type)ev.data.ptr);
 
-  if (epoll_ctl (eps->epfd, EPOLL_CTL_MOD, event, &ev) < 0)
+    if (epoll_ctl(eps->epfd, EPOLL_CTL_MOD, event, &ev) < 0)
     {
-      if (errno == ENOENT)
-	{
-	  if (epoll_ctl (eps->epfd, EPOLL_CTL_ADD, event, &ev) < 0)
-	    msg (M_ERR, "EVENT: epoll_ctl EPOLL_CTL_ADD failed, sd=%d", (int)event);
-	}
-      else
-	msg (M_ERR, "EVENT: epoll_ctl EPOLL_CTL_MOD failed, sd=%d", (int)event);
+        if (errno == ENOENT)
+        {
+            if (epoll_ctl(eps->epfd, EPOLL_CTL_ADD, event, &ev) < 0)
+            {
+                msg(M_ERR, "EVENT: epoll_ctl EPOLL_CTL_ADD failed, sd=%d", (int)event);
+            }
+        }
+        else
+        {
+            msg(M_ERR, "EVENT: epoll_ctl EPOLL_CTL_MOD failed, sd=%d", (int)event);
+        }
     }
 }
 
 static int
-ep_wait (struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
+ep_wait(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
 {
-  struct ep_set *eps = (struct ep_set *) es;
-  int stat;
+    struct ep_set *eps = (struct ep_set *) es;
+    int stat;
 
-  if (outlen > eps->maxevents)
-    outlen = eps->maxevents;
+    if (outlen > eps->maxevents)
+    {
+        outlen = eps->maxevents;
+    }
 
-  stat = epoll_wait (eps->epfd, eps->events, outlen, tv_to_ms_timeout (tv));
-  ASSERT (stat <= outlen);
+    stat = epoll_wait(eps->epfd, eps->events, outlen, tv_to_ms_timeout(tv));
+    ASSERT(stat <= outlen);
 
-  if (stat > 0)
+    if (stat > 0)
     {
-      int i;
-      const struct epoll_event *ev = eps->events;
-      struct event_set_return *esr = out;
-      for (i = 0; i < stat; ++i)
-	{
-	  esr->rwflags = 0;
-	  if (ev->events & (EPOLLIN|EPOLLPRI|EPOLLERR|EPOLLHUP))
-	    esr->rwflags |= EVENT_READ;
-	  if (ev->events & EPOLLOUT)
-	    esr->rwflags |= EVENT_WRITE;
-	  esr->arg = ev->data.ptr;
-	  dmsg (D_EVENT_WAIT, "EP_WAIT[%d] rwflags=0x%04x ev=0x%08x arg=" ptr_format,
-	       i, esr->rwflags, ev->events, (ptr_type)ev->data.ptr);
-	  ++ev;
-	  ++esr;
-	}
+        int i;
+        const struct epoll_event *ev = eps->events;
+        struct event_set_return *esr = out;
+        for (i = 0; i < stat; ++i)
+        {
+            esr->rwflags = 0;
+            if (ev->events & (EPOLLIN|EPOLLPRI|EPOLLERR|EPOLLHUP))
+            {
+                esr->rwflags |= EVENT_READ;
+            }
+            if (ev->events & EPOLLOUT)
+            {
+                esr->rwflags |= EVENT_WRITE;
+            }
+            esr->arg = ev->data.ptr;
+            dmsg(D_EVENT_WAIT, "EP_WAIT[%d] rwflags=0x%04x ev=0x%08x arg=" ptr_format,
+                 i, esr->rwflags, ev->events, (ptr_type)ev->data.ptr);
+            ++ev;
+            ++esr;
+        }
     }
-  return stat;
+    return stat;
 }
 
 static struct event_set *
-ep_init (int *maxevents, unsigned int flags)
+ep_init(int *maxevents, unsigned int flags)
 {
-  struct ep_set *eps;
-  int fd;
+    struct ep_set *eps;
+    int fd;
 
-  dmsg (D_EVENT_WAIT, "EP_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
+    dmsg(D_EVENT_WAIT, "EP_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
 
-  /* open epoll file descriptor */
-  fd = epoll_create (*maxevents);
-  if (fd < 0)
-    return NULL;
+    /* open epoll file descriptor */
+    fd = epoll_create(*maxevents);
+    if (fd < 0)
+    {
+        return NULL;
+    }
 
-  set_cloexec (fd);
+    set_cloexec(fd);
 
-  ALLOC_OBJ_CLEAR (eps, struct ep_set);
+    ALLOC_OBJ_CLEAR(eps, struct ep_set);
 
-  /* set dispatch functions */
-  eps->func.free = ep_free;
-  eps->func.reset = ep_reset;
-  eps->func.del = ep_del;
-  eps->func.ctl = ep_ctl;
-  eps->func.wait = ep_wait;
+    /* set dispatch functions */
+    eps->func.free = ep_free;
+    eps->func.reset = ep_reset;
+    eps->func.del = ep_del;
+    eps->func.ctl = ep_ctl;
+    eps->func.wait = ep_wait;
 
-  /* fast method ("sort of") corresponds to epoll one-shot */
-  if (flags & EVENT_METHOD_FAST)
-    eps->fast = true;
+    /* fast method ("sort of") corresponds to epoll one-shot */
+    if (flags & EVENT_METHOD_FAST)
+    {
+        eps->fast = true;
+    }
 
-  /* allocate space for epoll_wait return */
-  ASSERT (*maxevents > 0);
-  eps->maxevents = *maxevents;
-  ALLOC_ARRAY_CLEAR (eps->events, struct epoll_event, eps->maxevents);
+    /* allocate space for epoll_wait return */
+    ASSERT(*maxevents > 0);
+    eps->maxevents = *maxevents;
+    ALLOC_ARRAY_CLEAR(eps->events, struct epoll_event, eps->maxevents);
 
-  /* set epoll control fd */
-  eps->epfd = fd;
+    /* set epoll control fd */
+    eps->epfd = fd;
 
-  return (struct event_set *) eps;
+    return (struct event_set *) eps;
 }
 #endif /* EPOLL */
 
@@ -614,191 +685,207 @@ ep_init (int *maxevents, unsigned int flags)
 
 struct po_set
 {
-  struct event_set_functions func;
-  bool fast;
-  struct pollfd *events;
-  void **args;
-  int n_events;
-  int capacity;
+    struct event_set_functions func;
+    bool fast;
+    struct pollfd *events;
+    void **args;
+    int n_events;
+    int capacity;
 };
 
 static void
-po_free (struct event_set *es)
+po_free(struct event_set *es)
 {
-  struct po_set *pos = (struct po_set *) es;
-  free (pos->events);
-  free (pos->args);
-  free (pos);
+    struct po_set *pos = (struct po_set *) es;
+    free(pos->events);
+    free(pos->args);
+    free(pos);
 }
 
 static void
-po_reset (struct event_set *es)
+po_reset(struct event_set *es)
 {
-  struct po_set *pos = (struct po_set *) es;
-  ASSERT (pos->fast);
-  pos->n_events = 0;
+    struct po_set *pos = (struct po_set *) es;
+    ASSERT(pos->fast);
+    pos->n_events = 0;
 }
 
 static void
-po_del (struct event_set *es, event_t event)
+po_del(struct event_set *es, event_t event)
 {
-  struct po_set *pos = (struct po_set *) es;
-  int i;
+    struct po_set *pos = (struct po_set *) es;
+    int i;
 
-  dmsg (D_EVENT_WAIT, "PO_DEL ev=%d", (int)event);
+    dmsg(D_EVENT_WAIT, "PO_DEL ev=%d", (int)event);
 
-  ASSERT (!pos->fast);
-  for (i = 0; i < pos->n_events; ++i)
+    ASSERT(!pos->fast);
+    for (i = 0; i < pos->n_events; ++i)
     {
-      if (pos->events[i].fd == event)
-	{
-	  int j;
-	  for (j = i; j < pos->n_events - 1; ++j)
-	    {
-	      pos->events[j] = pos->events[j+1];
-	      pos->args[j] = pos->args[j+1];
-	    }
-	  --pos->n_events;
-	  break;
-	}
+        if (pos->events[i].fd == event)
+        {
+            int j;
+            for (j = i; j < pos->n_events - 1; ++j)
+            {
+                pos->events[j] = pos->events[j+1];
+                pos->args[j] = pos->args[j+1];
+            }
+            --pos->n_events;
+            break;
+        }
     }
 }
 
 static inline void
-po_set_pollfd_events (struct pollfd *pfdp, unsigned int rwflags)
+po_set_pollfd_events(struct pollfd *pfdp, unsigned int rwflags)
 {
-  pfdp->events = 0;
-  if (rwflags & EVENT_WRITE)
-    pfdp->events |= POLLOUT;
-  if (rwflags & EVENT_READ)
-    pfdp->events |= (POLLIN|POLLPRI);
+    pfdp->events = 0;
+    if (rwflags & EVENT_WRITE)
+    {
+        pfdp->events |= POLLOUT;
+    }
+    if (rwflags & EVENT_READ)
+    {
+        pfdp->events |= (POLLIN|POLLPRI);
+    }
 }
 
 static inline bool
-po_append_event (struct po_set *pos, event_t event, unsigned int rwflags, void *arg)
+po_append_event(struct po_set *pos, event_t event, unsigned int rwflags, void *arg)
 {
-  if (pos->n_events < pos->capacity)
+    if (pos->n_events < pos->capacity)
     {
-      struct pollfd *pfdp = &pos->events[pos->n_events];
-      pfdp->fd = event;
-      pos->args[pos->n_events] = arg;
-      po_set_pollfd_events (pfdp, rwflags);
-      ++pos->n_events;
-      return true;
+        struct pollfd *pfdp = &pos->events[pos->n_events];
+        pfdp->fd = event;
+        pos->args[pos->n_events] = arg;
+        po_set_pollfd_events(pfdp, rwflags);
+        ++pos->n_events;
+        return true;
+    }
+    else
+    {
+        return false;
     }
-  else
-    return false;
 }
 
 static void
-po_ctl (struct event_set *es, event_t event, unsigned int rwflags, void *arg)
+po_ctl(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
 {
-  struct po_set *pos = (struct po_set *) es;
+    struct po_set *pos = (struct po_set *) es;
 
-  dmsg (D_EVENT_WAIT, "PO_CTL rwflags=0x%04x ev=%d arg=" ptr_format,
-       rwflags, (int)event, (ptr_type)arg);
+    dmsg(D_EVENT_WAIT, "PO_CTL rwflags=0x%04x ev=%d arg=" ptr_format,
+         rwflags, (int)event, (ptr_type)arg);
 
-  if (pos->fast)
+    if (pos->fast)
     {
-      if (!po_append_event (pos, event, rwflags, arg))
-	goto err;
+        if (!po_append_event(pos, event, rwflags, arg))
+        {
+            goto err;
+        }
     }
-  else
+    else
     {
-      int i;
-      for (i = 0; i < pos->n_events; ++i)
-	{
-	  struct pollfd *pfdp = &pos->events[i];
-	  if (pfdp->fd == event)
-	    {
-	      pos->args[i] = arg;
-	      po_set_pollfd_events (pfdp, rwflags);
-	      goto done;
-	    }
-	}
-      if (!po_append_event (pos, event, rwflags, arg))
-	goto err;
+        int i;
+        for (i = 0; i < pos->n_events; ++i)
+        {
+            struct pollfd *pfdp = &pos->events[i];
+            if (pfdp->fd == event)
+            {
+                pos->args[i] = arg;
+                po_set_pollfd_events(pfdp, rwflags);
+                goto done;
+            }
+        }
+        if (!po_append_event(pos, event, rwflags, arg))
+        {
+            goto err;
+        }
     }
 
- done:
-  return;
+done:
+    return;
 
- err:
-  msg (D_EVENT_ERRORS, "Error: poll: too many I/O wait events");
+err:
+    msg(D_EVENT_ERRORS, "Error: poll: too many I/O wait events");
 }
 
 static int
-po_wait (struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
+po_wait(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
 {
-  struct po_set *pos = (struct po_set *) es;
-  int stat;
+    struct po_set *pos = (struct po_set *) es;
+    int stat;
 
-  stat = poll (pos->events, pos->n_events, tv_to_ms_timeout (tv));
+    stat = poll(pos->events, pos->n_events, tv_to_ms_timeout(tv));
 
-  ASSERT (stat <= pos->n_events);
+    ASSERT(stat <= pos->n_events);
 
-  if (stat > 0)
+    if (stat > 0)
     {
-      int i, j=0;
-      const struct pollfd *pfdp = pos->events;
-      for (i = 0; i < pos->n_events && j < outlen; ++i)
-	{
-	  if (pfdp->revents & (POLLIN|POLLPRI|POLLERR|POLLHUP|POLLOUT))
-	    {
-	      out->rwflags = 0;
-	      if (pfdp->revents & (POLLIN|POLLPRI|POLLERR|POLLHUP))
-		out->rwflags |= EVENT_READ;
-	      if (pfdp->revents & POLLOUT)
-		out->rwflags |= EVENT_WRITE;
-	      out->arg = pos->args[i];
-	      dmsg (D_EVENT_WAIT, "PO_WAIT[%d,%d] fd=%d rev=0x%08x rwflags=0x%04x arg=" ptr_format " %s",
-		   i, j, pfdp->fd, pfdp->revents, out->rwflags, (ptr_type)out->arg, pos->fast ? "" : "[scalable]");
-	      ++out;
-	      ++j;
-	    }
-	  else if (pfdp->revents)
-	    {
-	      msg (D_EVENT_ERRORS, "Error: poll: unknown revents=0x%04x", (unsigned int)pfdp->revents);
-	    }
-	  ++pfdp;
-	}
-      return j;
+        int i, j = 0;
+        const struct pollfd *pfdp = pos->events;
+        for (i = 0; i < pos->n_events && j < outlen; ++i)
+        {
+            if (pfdp->revents & (POLLIN|POLLPRI|POLLERR|POLLHUP|POLLOUT))
+            {
+                out->rwflags = 0;
+                if (pfdp->revents & (POLLIN|POLLPRI|POLLERR|POLLHUP))
+                {
+                    out->rwflags |= EVENT_READ;
+                }
+                if (pfdp->revents & POLLOUT)
+                {
+                    out->rwflags |= EVENT_WRITE;
+                }
+                out->arg = pos->args[i];
+                dmsg(D_EVENT_WAIT, "PO_WAIT[%d,%d] fd=%d rev=0x%08x rwflags=0x%04x arg=" ptr_format " %s",
+                     i, j, pfdp->fd, pfdp->revents, out->rwflags, (ptr_type)out->arg, pos->fast ? "" : "[scalable]");
+                ++out;
+                ++j;
+            }
+            else if (pfdp->revents)
+            {
+                msg(D_EVENT_ERRORS, "Error: poll: unknown revents=0x%04x", (unsigned int)pfdp->revents);
+            }
+            ++pfdp;
+        }
+        return j;
     }
-  return stat;
+    return stat;
 }
 
 static struct event_set *
-po_init (int *maxevents, unsigned int flags)
+po_init(int *maxevents, unsigned int flags)
 {
-  struct po_set *pos;
+    struct po_set *pos;
 
-  dmsg (D_EVENT_WAIT, "PO_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
+    dmsg(D_EVENT_WAIT, "PO_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
 
-  ALLOC_OBJ_CLEAR (pos, struct po_set);
+    ALLOC_OBJ_CLEAR(pos, struct po_set);
 
-  /* set dispatch functions */
-  pos->func.free = po_free;
-  pos->func.reset = po_reset;
-  pos->func.del = po_del;
-  pos->func.ctl = po_ctl;
-  pos->func.wait = po_wait;
+    /* set dispatch functions */
+    pos->func.free = po_free;
+    pos->func.reset = po_reset;
+    pos->func.del = po_del;
+    pos->func.ctl = po_ctl;
+    pos->func.wait = po_wait;
 
-  if (flags & EVENT_METHOD_FAST)
-    pos->fast = true;
+    if (flags & EVENT_METHOD_FAST)
+    {
+        pos->fast = true;
+    }
 
-  pos->n_events = 0;
+    pos->n_events = 0;
 
-  /* Figure our event capacity */
-  ASSERT (*maxevents > 0);
-  pos->capacity = *maxevents;
+    /* Figure our event capacity */
+    ASSERT(*maxevents > 0);
+    pos->capacity = *maxevents;
 
-  /* Allocate space for pollfd structures to be passed to poll() */
-  ALLOC_ARRAY_CLEAR (pos->events, struct pollfd, pos->capacity);
+    /* Allocate space for pollfd structures to be passed to poll() */
+    ALLOC_ARRAY_CLEAR(pos->events, struct pollfd, pos->capacity);
 
-  /* Allocate space for event_set_return objects */
-  ALLOC_ARRAY_CLEAR (pos->args, void *, pos->capacity);
+    /* Allocate space for event_set_return objects */
+    ALLOC_ARRAY_CLEAR(pos->args, void *, pos->capacity);
 
-  return (struct event_set *) pos;
+    return (struct event_set *) pos;
 }
 #endif /* POLL */
 
@@ -806,259 +893,295 @@ po_init (int *maxevents, unsigned int flags)
 
 struct se_set
 {
-  struct event_set_functions func;
-  bool fast;
-  fd_set readfds;
-  fd_set writefds;
-  void **args;  /* allocated to capacity size */
-  int maxfd;    /* largest fd seen so far, always < capacity */
-  int capacity; /* fixed largest fd + 1 */
+    struct event_set_functions func;
+    bool fast;
+    fd_set readfds;
+    fd_set writefds;
+    void **args; /* allocated to capacity size */
+    int maxfd;  /* largest fd seen so far, always < capacity */
+    int capacity; /* fixed largest fd + 1 */
 };
 
 static void
-se_free (struct event_set *es)
+se_free(struct event_set *es)
 {
-  struct se_set *ses = (struct se_set *) es;
-  free (ses->args);
-  free (ses);
+    struct se_set *ses = (struct se_set *) es;
+    free(ses->args);
+    free(ses);
 }
 
 static void
-se_reset (struct event_set *es)
+se_reset(struct event_set *es)
 {
-  struct se_set *ses = (struct se_set *) es;
-  int i;
-  ASSERT (ses->fast);
-  
-  dmsg (D_EVENT_WAIT, "SE_RESET");
-
-  FD_ZERO (&ses->readfds);
-  FD_ZERO (&ses->writefds);
-  for (i = 0; i <= ses->maxfd; ++i)
-    ses->args[i] = NULL;
-  ses->maxfd = -1;
+    struct se_set *ses = (struct se_set *) es;
+    int i;
+    ASSERT(ses->fast);
+
+    dmsg(D_EVENT_WAIT, "SE_RESET");
+
+    FD_ZERO(&ses->readfds);
+    FD_ZERO(&ses->writefds);
+    for (i = 0; i <= ses->maxfd; ++i)
+        ses->args[i] = NULL;
+    ses->maxfd = -1;
 }
 
 static void
-se_del (struct event_set *es, event_t event)
+se_del(struct event_set *es, event_t event)
 {
-  struct se_set *ses = (struct se_set *) es;
-  ASSERT (!ses->fast);
+    struct se_set *ses = (struct se_set *) es;
+    ASSERT(!ses->fast);
 
-  dmsg (D_EVENT_WAIT, "SE_DEL ev=%d", (int)event);
+    dmsg(D_EVENT_WAIT, "SE_DEL ev=%d", (int)event);
 
-  if (event >= 0 && event < ses->capacity)
+    if (event >= 0 && event < ses->capacity)
+    {
+        FD_CLR(event, &ses->readfds);
+        FD_CLR(event, &ses->writefds);
+        ses->args[event] = NULL;
+    }
+    else
     {
-      FD_CLR (event, &ses->readfds);
-      FD_CLR (event, &ses->writefds);
-      ses->args[event] = NULL;
+        msg(D_EVENT_ERRORS, "Error: select/se_del: too many I/O wait events");
     }
-  else
-    msg (D_EVENT_ERRORS, "Error: select/se_del: too many I/O wait events");
-  return;
+    return;
 }
 
 static void
-se_ctl (struct event_set *es, event_t event, unsigned int rwflags, void *arg)
+se_ctl(struct event_set *es, event_t event, unsigned int rwflags, void *arg)
 {
-  struct se_set *ses = (struct se_set *) es;
+    struct se_set *ses = (struct se_set *) es;
 
-  dmsg (D_EVENT_WAIT, "SE_CTL rwflags=0x%04x ev=%d fast=%d cap=%d maxfd=%d arg=" ptr_format,
-       rwflags, (int)event, (int)ses->fast, ses->capacity, ses->maxfd, (ptr_type)arg);
+    dmsg(D_EVENT_WAIT, "SE_CTL rwflags=0x%04x ev=%d fast=%d cap=%d maxfd=%d arg=" ptr_format,
+         rwflags, (int)event, (int)ses->fast, ses->capacity, ses->maxfd, (ptr_type)arg);
 
-  if (event >= 0 && event < ses->capacity)
+    if (event >= 0 && event < ses->capacity)
     {
-      ses->maxfd = max_int (event, ses->maxfd);
-      ses->args[event] = arg;
-      if (ses->fast)
-	{
-	  if (rwflags & EVENT_READ)
-	    openvpn_fd_set (event, &ses->readfds);
-	  if (rwflags & EVENT_WRITE)
-	    openvpn_fd_set (event, &ses->writefds);
-	}
-      else
-	{
-	  if (rwflags & EVENT_READ)
-	    openvpn_fd_set (event, &ses->readfds);
-	  else
-	    FD_CLR (event, &ses->readfds);
-	  if (rwflags & EVENT_WRITE)
-	    openvpn_fd_set (event, &ses->writefds);
-	  else
-	    FD_CLR (event, &ses->writefds);
-	}
+        ses->maxfd = max_int(event, ses->maxfd);
+        ses->args[event] = arg;
+        if (ses->fast)
+        {
+            if (rwflags & EVENT_READ)
+            {
+                openvpn_fd_set(event, &ses->readfds);
+            }
+            if (rwflags & EVENT_WRITE)
+            {
+                openvpn_fd_set(event, &ses->writefds);
+            }
+        }
+        else
+        {
+            if (rwflags & EVENT_READ)
+            {
+                openvpn_fd_set(event, &ses->readfds);
+            }
+            else
+            {
+                FD_CLR(event, &ses->readfds);
+            }
+            if (rwflags & EVENT_WRITE)
+            {
+                openvpn_fd_set(event, &ses->writefds);
+            }
+            else
+            {
+                FD_CLR(event, &ses->writefds);
+            }
+        }
     }
-  else
+    else
     {
-      msg (D_EVENT_ERRORS, "Error: select: too many I/O wait events, fd=%d cap=%d",
-	   (int) event,
-	   ses->capacity);
+        msg(D_EVENT_ERRORS, "Error: select: too many I/O wait events, fd=%d cap=%d",
+            (int) event,
+            ses->capacity);
     }
 }
 
 static int
-se_wait_return (struct se_set *ses,
-		fd_set *read,
-		fd_set *write,
-		struct event_set_return *out,
-		int outlen)
+se_wait_return(struct se_set *ses,
+               fd_set *read,
+               fd_set *write,
+               struct event_set_return *out,
+               int outlen)
 {
-  int i, j = 0;
-  for (i = 0; i <= ses->maxfd && j < outlen; ++i)
+    int i, j = 0;
+    for (i = 0; i <= ses->maxfd && j < outlen; ++i)
     {
-      const bool r = FD_ISSET (i, read);
-      const bool w = FD_ISSET (i, write);
-      if (r || w)
-	{
-	  out->rwflags = 0;
-	  if (r)
-	    out->rwflags |= EVENT_READ;
-	  if (w)
-	    out->rwflags |= EVENT_WRITE;
-	  out->arg = ses->args[i];
-	  dmsg (D_EVENT_WAIT, "SE_WAIT[%d,%d] rwflags=0x%04x arg=" ptr_format,
-	       i, j, out->rwflags, (ptr_type)out->arg);
-	  ++out;
-	  ++j;
-	}
+        const bool r = FD_ISSET(i, read);
+        const bool w = FD_ISSET(i, write);
+        if (r || w)
+        {
+            out->rwflags = 0;
+            if (r)
+            {
+                out->rwflags |= EVENT_READ;
+            }
+            if (w)
+            {
+                out->rwflags |= EVENT_WRITE;
+            }
+            out->arg = ses->args[i];
+            dmsg(D_EVENT_WAIT, "SE_WAIT[%d,%d] rwflags=0x%04x arg=" ptr_format,
+                 i, j, out->rwflags, (ptr_type)out->arg);
+            ++out;
+            ++j;
+        }
     }
-  return j;
+    return j;
 }
 
 static int
-se_wait_fast (struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
+se_wait_fast(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
 {
-  struct se_set *ses = (struct se_set *) es;
-  struct timeval tv_tmp = *tv;
-  int stat;
+    struct se_set *ses = (struct se_set *) es;
+    struct timeval tv_tmp = *tv;
+    int stat;
 
-  dmsg (D_EVENT_WAIT, "SE_WAIT_FAST maxfd=%d tv=%d/%d",
-	ses->maxfd,
-	(int)tv_tmp.tv_sec,
-	(int)tv_tmp.tv_usec);
+    dmsg(D_EVENT_WAIT, "SE_WAIT_FAST maxfd=%d tv=%d/%d",
+         ses->maxfd,
+         (int)tv_tmp.tv_sec,
+         (int)tv_tmp.tv_usec);
 
-  stat = select (ses->maxfd + 1, &ses->readfds, &ses->writefds, NULL, &tv_tmp);
+    stat = select(ses->maxfd + 1, &ses->readfds, &ses->writefds, NULL, &tv_tmp);
 
-  if (stat > 0)
-    stat = se_wait_return (ses, &ses->readfds, &ses->writefds, out, outlen);
+    if (stat > 0)
+    {
+        stat = se_wait_return(ses, &ses->readfds, &ses->writefds, out, outlen);
+    }
 
-  return stat;
+    return stat;
 }
 
 static int
-se_wait_scalable (struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
+se_wait_scalable(struct event_set *es, const struct timeval *tv, struct event_set_return *out, int outlen)
 {
-  struct se_set *ses = (struct se_set *) es;
-  struct timeval tv_tmp = *tv;
-  fd_set read = ses->readfds;
-  fd_set write = ses->writefds;
-  int stat;
+    struct se_set *ses = (struct se_set *) es;
+    struct timeval tv_tmp = *tv;
+    fd_set read = ses->readfds;
+    fd_set write = ses->writefds;
+    int stat;
 
-  dmsg (D_EVENT_WAIT, "SE_WAIT_SCALEABLE maxfd=%d tv=%d/%d",
-	ses->maxfd, (int)tv_tmp.tv_sec, (int)tv_tmp.tv_usec);
+    dmsg(D_EVENT_WAIT, "SE_WAIT_SCALEABLE maxfd=%d tv=%d/%d",
+         ses->maxfd, (int)tv_tmp.tv_sec, (int)tv_tmp.tv_usec);
 
-  stat = select (ses->maxfd + 1, &read, &write, NULL, &tv_tmp);
+    stat = select(ses->maxfd + 1, &read, &write, NULL, &tv_tmp);
 
-  if (stat > 0)
-    stat = se_wait_return (ses, &read, &write, out, outlen);
+    if (stat > 0)
+    {
+        stat = se_wait_return(ses, &read, &write, out, outlen);
+    }
 
-  return stat;
+    return stat;
 }
 
 static struct event_set *
-se_init (int *maxevents, unsigned int flags)
+se_init(int *maxevents, unsigned int flags)
 {
-  struct se_set *ses;
+    struct se_set *ses;
 
-  dmsg (D_EVENT_WAIT, "SE_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
+    dmsg(D_EVENT_WAIT, "SE_INIT maxevents=%d flags=0x%08x", *maxevents, flags);
 
-  ALLOC_OBJ_CLEAR (ses, struct se_set);
+    ALLOC_OBJ_CLEAR(ses, struct se_set);
 
-  /* set dispatch functions */
-  ses->func.free = se_free;
-  ses->func.reset = se_reset;
-  ses->func.del = se_del;
-  ses->func.ctl = se_ctl;
-  ses->func.wait = se_wait_scalable;
+    /* set dispatch functions */
+    ses->func.free = se_free;
+    ses->func.reset = se_reset;
+    ses->func.del = se_del;
+    ses->func.ctl = se_ctl;
+    ses->func.wait = se_wait_scalable;
 
-  if (flags & EVENT_METHOD_FAST)
+    if (flags & EVENT_METHOD_FAST)
     {
-      ses->fast = true;
-      ses->func.wait = se_wait_fast;
+        ses->fast = true;
+        ses->func.wait = se_wait_fast;
     }
 
-  /* Select needs to be passed this value + 1 */
-  ses->maxfd = -1;
+    /* Select needs to be passed this value + 1 */
+    ses->maxfd = -1;
 
-  /* Set our event capacity */
-  ASSERT (*maxevents > 0);
-  *maxevents = min_int (*maxevents, SELECT_MAX_FDS);
-  ses->capacity = SELECT_MAX_FDS;
+    /* Set our event capacity */
+    ASSERT(*maxevents > 0);
+    *maxevents = min_int(*maxevents, SELECT_MAX_FDS);
+    ses->capacity = SELECT_MAX_FDS;
 
-  /* Allocate space for event_set_return void * args */
-  ALLOC_ARRAY_CLEAR (ses->args, void *, ses->capacity);
+    /* Allocate space for event_set_return void * args */
+    ALLOC_ARRAY_CLEAR(ses->args, void *, ses->capacity);
 
-  return (struct event_set *) ses;
+    return (struct event_set *) ses;
 }
 #endif /* SELECT */
 
 static struct event_set *
-event_set_init_simple (int *maxevents, unsigned int flags)
+event_set_init_simple(int *maxevents, unsigned int flags)
 {
-  struct event_set *ret = NULL;
+    struct event_set *ret = NULL;
 #ifdef _WIN32
-  ret = we_init (maxevents, flags);
+    ret = we_init(maxevents, flags);
 #elif POLL && SELECT
 #if 0 /* Define to 1 if EVENT_METHOD_US_TIMEOUT should cause select to be favored over poll */
-  if (flags & EVENT_METHOD_US_TIMEOUT)
-    ret = se_init (maxevents, flags); 
+    if (flags & EVENT_METHOD_US_TIMEOUT)
+    {
+        ret = se_init(maxevents, flags);
+    }
+#endif
+#ifdef SELECT_PREFERRED_OVER_POLL
+    if (!ret)
+    {
+        ret = se_init(maxevents, flags);
+    }
+    if (!ret)
+    {
+        ret = po_init(maxevents, flags);
+    }
+#else  /* ifdef SELECT_PREFERRED_OVER_POLL */
+    if (!ret)
+    {
+        ret = po_init(maxevents, flags);
+    }
+    if (!ret)
+    {
+        ret = se_init(maxevents, flags);
+    }
 #endif
-# ifdef SELECT_PREFERRED_OVER_POLL
-   if (!ret)
-     ret = se_init (maxevents, flags);
-   if (!ret)
-     ret = po_init (maxevents, flags);
-# else
-   if (!ret)
-     ret = po_init (maxevents, flags);
-   if (!ret)
-     ret = se_init (maxevents, flags);
-# endif
 #elif POLL
-  ret = po_init (maxevents, flags);
+    ret = po_init(maxevents, flags);
 #elif SELECT
-  ret = se_init (maxevents, flags);
-#else
+    ret = se_init(maxevents, flags);
+#else  /* ifdef _WIN32 */
 #error At least one of poll, select, or WSAWaitForMultipleEvents must be supported by the kernel
-#endif
-  ASSERT (ret);
-  return ret;
+#endif /* ifdef _WIN32 */
+    ASSERT(ret);
+    return ret;
 }
 
 static struct event_set *
-event_set_init_scalable (int *maxevents, unsigned int flags)
+event_set_init_scalable(int *maxevents, unsigned int flags)
 {
-  struct event_set *ret = NULL;
+    struct event_set *ret = NULL;
 #if EPOLL
-  ret = ep_init (maxevents, flags);
-  if (!ret)
+    ret = ep_init(maxevents, flags);
+    if (!ret)
     {
-      msg (M_WARN, "Note: sys_epoll API is unavailable, falling back to poll/select API");
-      ret = event_set_init_simple (maxevents, flags);
+        msg(M_WARN, "Note: sys_epoll API is unavailable, falling back to poll/select API");
+        ret = event_set_init_simple(maxevents, flags);
     }
-#else
-  ret = event_set_init_simple (maxevents, flags);
+#else  /* if EPOLL */
+    ret = event_set_init_simple(maxevents, flags);
 #endif
-  ASSERT (ret);
-  return ret;
+    ASSERT(ret);
+    return ret;
 }
 
 struct event_set *
-event_set_init (int *maxevents, unsigned int flags)
+event_set_init(int *maxevents, unsigned int flags)
 {
-  if (flags & EVENT_METHOD_FAST)
-    return event_set_init_simple (maxevents, flags);
-  else
-    return event_set_init_scalable (maxevents, flags);
+    if (flags & EVENT_METHOD_FAST)
+    {
+        return event_set_init_simple(maxevents, flags);
+    }
+    else
+    {
+        return event_set_init_scalable(maxevents, flags);
+    }
 }