1 files changed, 90 insertions, 88 deletions

diff --git a/src/microhttpd/mhd_mono_clock.c b/src/microhttpd/mhd_mono_clock.c
index 97dbfb9f..eee911fb 100644
--- a/src/microhttpd/mhd_mono_clock.c
+++ b/src/microhttpd/mhd_mono_clock.c
@@ -76,7 +76,8 @@ static clockid_t mono_clock_id = _MHD_UNWANTED_CLOCK;
 #endif /* HAVE_CLOCK_GETTIME */
 
 /* sync clocks; reduce chance of value wrap */
-#if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_CLOCK_GET_TIME) || defined(HAVE_GETHRTIME)
+#if defined(HAVE_CLOCK_GETTIME) || defined(HAVE_CLOCK_GET_TIME) || \
+  defined(HAVE_GETHRTIME)
 static time_t mono_clock_start;
 #endif /* HAVE_CLOCK_GETTIME || HAVE_CLOCK_GET_TIME || HAVE_GETHRTIME */
 static time_t sys_clock_start;
@@ -124,9 +125,9 @@ enum _MHD_mono_clock_source
    */
   _MHD_CLOCK_GETTICKCOUNT64,
 
-   /**
-    * QueryPerformanceCounter() / QueryPerformanceFrequency()
-    */
+  /**
+   * QueryPerformanceCounter() / QueryPerformanceFrequency()
+   */
   _MHD_CLOCK_PERFCOUNTER
 };
 
@@ -153,8 +154,8 @@ MHD_monotonic_sec_counter_init (void)
   /* just a little syntactic trick to get the
      various following ifdef's to work out nicely */
   if (0)
-    {
-    }
+  {
+  }
   else
 #ifdef HAVE_CLOCK_GETTIME
 #ifdef CLOCK_MONOTONIC_COARSE
@@ -163,11 +164,11 @@ MHD_monotonic_sec_counter_init (void)
   /* but preferred since it's fast */
   if (0 == clock_gettime (CLOCK_MONOTONIC_COARSE,
                           &ts))
-    {
-      mono_clock_id = CLOCK_MONOTONIC_COARSE;
-      mono_clock_start = ts.tv_sec;
-      mono_clock_source = _MHD_CLOCK_GETTIME;
-    }
+  {
+    mono_clock_id = CLOCK_MONOTONIC_COARSE;
+    mono_clock_start = ts.tv_sec;
+    mono_clock_source = _MHD_CLOCK_GETTIME;
+  }
   else
 #endif /* CLOCK_MONOTONIC_COARSE */
 #ifdef CLOCK_MONOTONIC_FAST
@@ -175,11 +176,11 @@ MHD_monotonic_sec_counter_init (void)
   /* Can be affected by frequency adjustment, but preferred since it's fast */
   if (0 == clock_gettime (CLOCK_MONOTONIC_FAST,
                           &ts))
-    {
-      mono_clock_id = CLOCK_MONOTONIC_FAST;
-      mono_clock_start = ts.tv_sec;
-      mono_clock_source = _MHD_CLOCK_GETTIME;
-    }
+  {
+    mono_clock_id = CLOCK_MONOTONIC_FAST;
+    mono_clock_start = ts.tv_sec;
+    mono_clock_source = _MHD_CLOCK_GETTIME;
+  }
   else
 #endif /* CLOCK_MONOTONIC_COARSE */
 #ifdef CLOCK_MONOTONIC_RAW
@@ -187,11 +188,11 @@ MHD_monotonic_sec_counter_init (void)
   /* Not affected by frequency adjustment, but don't count time in suspend */
   if (0 == clock_gettime (CLOCK_MONOTONIC_RAW,
                           &ts))
-    {
-      mono_clock_id = CLOCK_MONOTONIC_RAW;
-      mono_clock_start = ts.tv_sec;
-      mono_clock_source = _MHD_CLOCK_GETTIME;
-    }
+  {
+    mono_clock_id = CLOCK_MONOTONIC_RAW;
+    mono_clock_start = ts.tv_sec;
+    mono_clock_source = _MHD_CLOCK_GETTIME;
+  }
   else
 #endif /* CLOCK_MONOTONIC_RAW */
 #ifdef CLOCK_BOOTTIME
@@ -200,11 +201,11 @@ MHD_monotonic_sec_counter_init (void)
   /* but can be slower value-getting than other clocks */
   if (0 == clock_gettime (CLOCK_BOOTTIME,
                           &ts))
-    {
-      mono_clock_id = CLOCK_BOOTTIME;
-      mono_clock_start = ts.tv_sec;
-      mono_clock_source = _MHD_CLOCK_GETTIME;
-    }
+  {
+    mono_clock_id = CLOCK_BOOTTIME;
+    mono_clock_start = ts.tv_sec;
+    mono_clock_source = _MHD_CLOCK_GETTIME;
+  }
   else
 #endif /* CLOCK_BOOTTIME */
 #ifdef CLOCK_MONOTONIC
@@ -213,11 +214,11 @@ MHD_monotonic_sec_counter_init (void)
   /* On Linux it's not truly monotonic as it doesn't count time in suspend */
   if (0 == clock_gettime (CLOCK_MONOTONIC,
                           &ts))
-    {
-      mono_clock_id = CLOCK_MONOTONIC;
-      mono_clock_start = ts.tv_sec;
-      mono_clock_source = _MHD_CLOCK_GETTIME;
-    }
+  {
+    mono_clock_id = CLOCK_MONOTONIC;
+    mono_clock_start = ts.tv_sec;
+    mono_clock_source = _MHD_CLOCK_GETTIME;
+  }
   else
 #endif /* CLOCK_BOOTTIME */
 #endif /* HAVE_CLOCK_GETTIME */
@@ -225,15 +226,15 @@ MHD_monotonic_sec_counter_init (void)
   /* Darwin-specific monotonic clock */
   /* Should be monotonic as clock_set_time function always unconditionally */
   /* failed on latest kernels */
-  if ( (KERN_SUCCESS == host_get_clock_service (mach_host_self(),
+  if ( (KERN_SUCCESS == host_get_clock_service (mach_host_self (),
                                                 SYSTEM_CLOCK,
                                                 &mono_clock_service)) &&
        (KERN_SUCCESS == clock_get_time (mono_clock_service,
                                         &cur_time)) )
-    {
-      mono_clock_start = cur_time.tv_sec;
-      mono_clock_source = _MHD_CLOCK_GET_TIME;
-    }
+  {
+    mono_clock_start = cur_time.tv_sec;
+    mono_clock_source = _MHD_CLOCK_GET_TIME;
+  }
   else
 #endif /* HAVE_CLOCK_GET_TIME */
 #ifdef _WIN32
@@ -241,25 +242,25 @@ MHD_monotonic_sec_counter_init (void)
   /* W32 Vista or later specific monotonic clock */
   /* Available since Vista, ~15ms accuracy */
   if (1)
-    {
-      tick_start = GetTickCount64 ();
-      mono_clock_source = _MHD_CLOCK_GETTICKCOUNT64;
-    }
+  {
+    tick_start = GetTickCount64 ();
+    mono_clock_source = _MHD_CLOCK_GETTICKCOUNT64;
+  }
   else
 #else  /* _WIN32_WINNT < 0x0600 */
   /* W32 specific monotonic clock */
   /* Available on Windows 2000 and later */
   if (1)
-    {
-      LARGE_INTEGER freq;
-      LARGE_INTEGER perf_counter;
-
-      QueryPerformanceFrequency (&freq); /* never fail on XP and later */
-      QueryPerformanceCounter (&perf_counter); /* never fail on XP and later */
-      perf_freq = freq.QuadPart;
-      perf_start = perf_counter.QuadPart;
-      mono_clock_source = _MHD_CLOCK_PERFCOUNTER;
-    }
+  {
+    LARGE_INTEGER freq;
+    LARGE_INTEGER perf_counter;
+
+    QueryPerformanceFrequency (&freq);   /* never fail on XP and later */
+    QueryPerformanceCounter (&perf_counter);   /* never fail on XP and later */
+    perf_freq = freq.QuadPart;
+    perf_start = perf_counter.QuadPart;
+    mono_clock_source = _MHD_CLOCK_PERFCOUNTER;
+  }
   else
 #endif /* _WIN32_WINNT < 0x0600 */
 #endif /* _WIN32 */
@@ -269,11 +270,11 @@ MHD_monotonic_sec_counter_init (void)
   /* Not preferred due to be potentially resource-hungry */
   if (0 == clock_gettime (CLOCK_HIGHRES,
                           &ts))
-    {
-      mono_clock_id = CLOCK_HIGHRES;
-      mono_clock_start = ts.tv_sec;
-      mono_clock_source = _MHD_CLOCK_GETTIME;
-    }
+  {
+    mono_clock_id = CLOCK_HIGHRES;
+    mono_clock_start = ts.tv_sec;
+    mono_clock_source = _MHD_CLOCK_GETTIME;
+  }
   else
 #endif /* CLOCK_HIGHRES */
 #endif /* HAVE_CLOCK_GETTIME */
@@ -281,26 +282,26 @@ MHD_monotonic_sec_counter_init (void)
   /* HP-UX and Solaris monotonic clock */
   /* Not preferred due to be potentially resource-hungry */
   if (1)
-    {
-      hrtime_start = gethrtime ();
-      mono_clock_source = _MHD_CLOCK_GETHRTIME;
-    }
+  {
+    hrtime_start = gethrtime ();
+    mono_clock_source = _MHD_CLOCK_GETHRTIME;
+  }
   else
 #endif /* HAVE_GETHRTIME */
-    {
-      /* no suitable clock source was found */
-      mono_clock_source = _MHD_CLOCK_NO_SOURCE;
-    }
+  {
+    /* no suitable clock source was found */
+    mono_clock_source = _MHD_CLOCK_NO_SOURCE;
+  }
 
 #ifdef HAVE_CLOCK_GET_TIME
   if ( (_MHD_CLOCK_GET_TIME != mono_clock_source) &&
        (_MHD_INVALID_CLOCK_SERV != mono_clock_service) )
-    {
-      /* clock service was initialised but clock_get_time failed */
-      mach_port_deallocate (mach_task_self(),
-                            mono_clock_service);
-      mono_clock_service = _MHD_INVALID_CLOCK_SERV;
-    }
+  {
+    /* clock service was initialised but clock_get_time failed */
+    mach_port_deallocate (mach_task_self (),
+                          mono_clock_service);
+    mono_clock_service = _MHD_INVALID_CLOCK_SERV;
+  }
 #else
   (void) mono_clock_source; /* avoid compiler warning */
 #endif /* HAVE_CLOCK_GET_TIME */
@@ -317,11 +318,11 @@ MHD_monotonic_sec_counter_finish (void)
 {
 #ifdef HAVE_CLOCK_GET_TIME
   if (_MHD_INVALID_CLOCK_SERV != mono_clock_service)
-    {
-      mach_port_deallocate (mach_task_self(),
-                            mono_clock_service);
-      mono_clock_service = _MHD_INVALID_CLOCK_SERV;
-    }
+  {
+    mach_port_deallocate (mach_task_self (),
+                          mono_clock_service);
+    mono_clock_service = _MHD_INVALID_CLOCK_SERV;
+  }
 #endif /* HAVE_CLOCK_GET_TIME */
 }
 
@@ -340,37 +341,38 @@ MHD_monotonic_sec_counter (void)
   struct timespec ts;
 
   if ( (_MHD_UNWANTED_CLOCK != mono_clock_id) &&
-       (0 == clock_gettime (mono_clock_id ,
+       (0 == clock_gettime (mono_clock_id,
                             &ts)) )
     return ts.tv_sec - mono_clock_start;
 #endif /* HAVE_CLOCK_GETTIME */
 #ifdef HAVE_CLOCK_GET_TIME
   if (_MHD_INVALID_CLOCK_SERV != mono_clock_service)
-    {
-      mach_timespec_t cur_time;
+  {
+    mach_timespec_t cur_time;
 
-      if (KERN_SUCCESS == clock_get_time(mono_clock_service,
-                                         &cur_time))
-        return cur_time.tv_sec - mono_clock_start;
-    }
+    if (KERN_SUCCESS == clock_get_time (mono_clock_service,
+                                        &cur_time))
+      return cur_time.tv_sec - mono_clock_start;
+  }
 #endif /* HAVE_CLOCK_GET_TIME */
 #if defined(_WIN32)
 #if _WIN32_WINNT >= 0x0600
   if (1)
-    return (time_t)(((uint64_t)(GetTickCount64() - tick_start)) / 1000);
+    return (time_t) (((uint64_t) (GetTickCount64 () - tick_start)) / 1000);
 #else  /* _WIN32_WINNT < 0x0600 */
   if (0 != perf_freq)
-    {
-      LARGE_INTEGER perf_counter;
+  {
+    LARGE_INTEGER perf_counter;
 
-      QueryPerformanceCounter (&perf_counter); /* never fail on XP and later */
-      return (time_t)(((uint64_t)(perf_counter.QuadPart - perf_start)) / perf_freq);
-    }
+    QueryPerformanceCounter (&perf_counter);   /* never fail on XP and later */
+    return (time_t) (((uint64_t) (perf_counter.QuadPart - perf_start))
+                     / perf_freq);
+  }
 #endif /* _WIN32_WINNT < 0x0600 */
 #endif /* _WIN32 */
 #ifdef HAVE_GETHRTIME
   if (1)
-    return (time_t)(((uint64_t) (gethrtime () - hrtime_start)) / 1000000000);
+    return (time_t) (((uint64_t) (gethrtime () - hrtime_start)) / 1000000000);
 #endif /* HAVE_GETHRTIME */
 
   return time (NULL) - sys_clock_start;