Imported Upstream version 2.2.1upstream/2.2.1

1 files changed, 273 insertions, 0 deletions

diff --git a/otime.c b/otime.c
new file mode 100644
index 0000000..b295646
--- /dev/null
+++ b/otime.c
@@ -0,0 +1,273 @@
+/*
+ *  OpenVPN -- An application to securely tunnel IP networks
+ *             over a single TCP/UDP port, with support for SSL/TLS-based
+ *             session authentication and key exchange,
+ *             packet encryption, packet authentication, and
+ *             packet compression.
+ *
+ *  Copyright (C) 2002-2010 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
+ *  as published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program (see the file COPYING included with this
+ *  distribution); if not, write to the Free Software Foundation, Inc.,
+ *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "syshead.h"
+
+#include "otime.h"
+
+#include "memdbg.h"
+
+time_t now = 0;            /* GLOBAL */
+
+#if TIME_BACKTRACK_PROTECTION && defined(HAVE_GETTIMEOFDAY)
+
+static time_t now_adj = 0; /* GLOBAL */
+time_t now_usec = 0;       /* GLOBAL */
+
+/*
+ * Try to filter out time instability caused by the system
+ * clock backtracking or jumping forward.
+ */
+
+void
+update_now (const time_t system_time)
+{
+  const int forward_threshold = 86400; /* threshold at which to dampen forward jumps */
+  const int backward_trigger  = 10;    /* backward jump must be >= this many seconds before we adjust */
+  time_t real_time = system_time + now_adj;
+
+  if (real_time > now)
+    {
+      const time_t overshoot = real_time - now - 1;
+      if (overshoot > forward_threshold && now_adj >= overshoot)
+        {
+          now_adj -= overshoot;
+          real_time -= overshoot;
+        }
+      now = real_time;
+    }
+  else if (real_time < now - backward_trigger)
+    now_adj += (now - real_time);
+}
+
+void
+update_now_usec (struct timeval *tv)
+{
+  const time_t last = now;
+  update_now (tv->tv_sec);
+  if (now > last || (now == last && tv->tv_usec > now_usec))
+    now_usec = tv->tv_usec;
+}
+
+#endif /* TIME_BACKTRACK_PROTECTION && defined(HAVE_GETTIMEOFDAY) */
+
+/* 
+ * Return a numerical string describing a struct timeval.
+ */
+const char *
+tv_string (const struct timeval *tv, struct gc_arena *gc)
+{
+  struct buffer out = alloc_buf_gc (64, gc);
+  buf_printf (&out, "[%d/%d]",
+	      (int) tv->tv_sec,
+	      (int )tv->tv_usec);
+  return BSTR (&out);
+}
+
+/* 
+ * Return an ascii string describing an absolute
+ * date/time in a struct timeval.
+ * 
+ */
+const char *
+tv_string_abs (const struct timeval *tv, struct gc_arena *gc)
+{
+  return time_string ((time_t) tv->tv_sec,
+		      (int) tv->tv_usec,
+		      true,
+		      gc);
+}
+
+/* format a time_t as ascii, or use current time if 0 */
+
+const char *
+time_string (time_t t, int usec, bool show_usec, struct gc_arena *gc)
+{
+  struct buffer out = alloc_buf_gc (64, gc);
+  struct timeval tv;
+
+  if (t)
+    {
+      tv.tv_sec = t;
+      tv.tv_usec = usec;
+    }
+  else
+    {
+#ifdef HAVE_GETTIMEOFDAY
+      if (gettimeofday (&tv, NULL))
+#endif
+	{
+	  tv.tv_sec = time (NULL);
+	  tv.tv_usec = 0;
+	}
+    }
+
+  t = tv.tv_sec;
+  buf_printf (&out, "%s", ctime(&t));
+  buf_rmtail (&out, '\n');
+
+  if (show_usec && tv.tv_usec)
+    buf_printf (&out, " us=%d", (int)tv.tv_usec);
+
+  return BSTR (&out);
+}
+
+/*
+ * Limit the frequency of an event stream.
+ *
+ * Used to control maximum rate of new
+ * incoming connections.
+ */
+
+struct frequency_limit *
+frequency_limit_init (int max, int per)
+{
+  struct frequency_limit *f;
+
+  ASSERT (max >= 0 && per >= 0);
+
+  ALLOC_OBJ (f, struct frequency_limit);
+  f->max = max;
+  f->per = per;
+  f->n = 0;
+  f->reset = 0;
+  return f;
+}
+
+void
+frequency_limit_free (struct frequency_limit *f)
+{
+  free (f);
+}
+
+bool
+frequency_limit_event_allowed (struct frequency_limit *f)
+{
+  if (f->per)
+    {
+      bool ret;
+      if (now >= f->reset + f->per)
+	{
+	  f->reset = now;
+	  f->n = 0;
+	}
+      ret = (++f->n <= f->max);
+      return ret;
+    }
+  else
+    return true;
+}
+
+#ifdef WIN32
+
+static time_t gtc_base = 0;
+static DWORD gtc_last = 0;
+static time_t last_sec = 0;
+static unsigned int last_msec = 0;
+static bool bt_last = false;
+
+static void
+gettimeofday_calibrate (void)
+{
+  const time_t t = time(NULL);
+  const DWORD gtc = GetTickCount();
+  gtc_base = t - gtc/1000;
+  gtc_last = gtc;
+}
+
+/*
+ * Rewritten by JY for OpenVPN 2.1, after I realized that
+ * QueryPerformanceCounter takes nearly 2 orders of magnitude
+ * more processor cycles than GetTickCount.
+ */
+int
+gettimeofday (struct timeval *tv, void *tz)
+{
+  const DWORD gtc = GetTickCount();
+  bool bt = false;
+  time_t sec;
+  unsigned int msec;
+  const int backtrack_hold_seconds = 10;
+
+  /* recalibrate at the dreaded 49.7 day mark */
+  if (!gtc_base || gtc < gtc_last)
+    gettimeofday_calibrate ();
+  gtc_last = gtc;
+
+  sec = gtc_base + gtc / 1000;
+  msec = gtc % 1000;
+
+  if (sec == last_sec)
+    {
+      if (msec < last_msec)
+	{
+	  msec = last_msec;
+	  bt = true;
+	}
+    }
+  else if (sec < last_sec)
+    {
+      /* We try to dampen out backtracks of less than backtrack_hold_seconds.
+	 Larger backtracks will be passed through and dealt with by the
+	 TIME_BACKTRACK_PROTECTION code (if enabled) */
+      if (sec > last_sec - backtrack_hold_seconds)
+	{
+	  sec = last_sec;
+	  msec = last_msec;
+	}
+      bt = true;
+    }
+
+  tv->tv_sec = last_sec = sec;
+  tv->tv_usec = (last_msec = msec) * 1000;
+
+  if (bt && !bt_last)
+    gettimeofday_calibrate ();
+  bt_last = bt;
+
+  return 0;
+}
+
+#endif /* WIN32 */
+
+#ifdef TIME_TEST
+void
+time_test (void)
+{
+  struct timeval tv;
+  time_t t;
+  int i;
+  for (i = 0; i < 10000; ++i)
+    {
+      t = time(NULL);
+      gettimeofday (&tv, NULL);
+#if 1
+      msg (M_INFO, "t=%u s=%u us=%u",
+	       (unsigned int)t,
+	       (unsigned int)tv.tv_sec,
+	       (unsigned int)tv.tv_usec);
+#endif
+    }
+}
+#endif