openvpn/otime.h

/*
 *  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
 */

#ifndef OTIME_H
#define OTIME_H

#include "common.h"
#include "integer.h"
#include "buffer.h"

struct frequency_limit
{
  int max;
  int per;
  int n;
  time_t reset;
};

struct frequency_limit *frequency_limit_init (int max, int per);
void frequency_limit_free (struct frequency_limit *f);
bool frequency_limit_event_allowed (struct frequency_limit *f);

#ifdef WIN32
int gettimeofday(struct timeval *tv, void *tz);
#endif

/* 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 timeval functions */

const char *tv_string (const struct timeval *tv, struct gc_arena *gc);
const char *tv_string_abs (const struct timeval *tv, struct gc_arena *gc);

extern time_t now; /* updated frequently to time(NULL) */

void time_test (void);

#if TIME_BACKTRACK_PROTECTION && defined(HAVE_GETTIMEOFDAY)

void update_now (const time_t system_time);

extern time_t now_usec;
void update_now_usec (struct timeval *tv);

static inline int
openvpn_gettimeofday (struct timeval *tv, void *tz)
{
  const int status = gettimeofday (tv, tz);
  if (!status)
    {
      update_now_usec (tv);
      tv->tv_sec = now;
      tv->tv_usec = now_usec;
    }
  return status;
}

static inline void
update_time (void)
{
#ifdef WIN32
  /* on WIN32, gettimeofday is faster than time(NULL) */
  struct timeval tv;
  openvpn_gettimeofday (&tv, NULL);
#else
  update_now (time (NULL));
#endif
}

#else /* !(TIME_BACKTRACK_PROTECTION && defined(HAVE_GETTIMEOFDAY)) */

static inline void
update_time (void)
{
#if defined(WIN32) && defined(HAVE_GETTIMEOFDAY)
  struct timeval tv;
  if (!gettimeofday (&tv, NULL))
    {
      if (tv.tv_sec != now)
	now = tv.tv_sec;
    }
#else
  const time_t real_time = time (NULL);
  if (real_time != now)
    now = real_time;
#endif
}

#ifdef HAVE_GETTIMEOFDAY

static inline int
openvpn_gettimeofday (struct timeval *tv, void *tz)
{
  return gettimeofday (tv, tz);
}

#endif

#endif /* TIME_BACKTRACK_PROTECTION && defined(HAVE_GETTIMEOFDAY) */

static inline time_t
openvpn_time (time_t *t)
{
  update_time ();
  if (t)
    *t = now;
  return now;
}

static inline void
tv_clear (struct timeval *tv)
{
  tv->tv_sec = 0;
  tv->tv_usec = 0;
}

static inline bool
tv_defined (const struct timeval *tv)
{
  return tv->tv_sec > 0 && tv->tv_usec > 0;
}

/* return tv1 - tv2 in usec, constrained by max_seconds */
static inline int
tv_subtract (const struct timeval *tv1, const struct timeval *tv2, const unsigned int max_seconds)
{
  const int max_usec = max_seconds * 1000000;
  const int sec_diff = tv1->tv_sec - tv2->tv_sec;

  if (sec_diff > ((int)max_seconds + 10))
    return max_usec;
  else if (sec_diff < -((int)max_seconds + 10))
    return -max_usec;
  return constrain_int (sec_diff * 1000000 + (tv1->tv_usec - tv2->tv_usec), -max_usec, max_usec);
}

static inline void
tv_add (struct timeval *dest, const struct timeval *src)
{
  dest->tv_sec += src->tv_sec;
  dest->tv_usec += src->tv_usec;
  dest->tv_sec += (dest->tv_usec >> 20);
  dest->tv_usec &= 0x000FFFFF;
  if (dest->tv_usec >= 1000000)
    {
      dest->tv_usec -= 1000000;
      dest->tv_sec += 1;
    } 
}

static inline bool
tv_lt (const struct timeval *t1, const struct timeval *t2)
{
  if (t1->tv_sec < t2->tv_sec)
    return true;
  else if (t1->tv_sec > t2->tv_sec)
    return false;
  else
    return t1->tv_usec < t2->tv_usec;
}

static inline bool
tv_le (const struct timeval *t1, const struct timeval *t2)
{
  if (t1->tv_sec < t2->tv_sec)
    return true;
  else if (t1->tv_sec > t2->tv_sec)
    return false;
  else
    return t1->tv_usec <= t2->tv_usec;
}

static inline bool
tv_ge (const struct timeval *t1, const struct timeval *t2)
{
  if (t1->tv_sec > t2->tv_sec)
    return true;
  else if (t1->tv_sec < t2->tv_sec)
    return false;
  else
    return t1->tv_usec >= t2->tv_usec;
}

static inline bool
tv_gt (const struct timeval *t1, const struct timeval *t2)
{
  if (t1->tv_sec > t2->tv_sec)
    return true;
  else if (t1->tv_sec < t2->tv_sec)
    return false;
  else
    return t1->tv_usec > t2->tv_usec;
}

static inline bool
tv_eq (const struct timeval *t1, const struct timeval *t2)
{
  return t1->tv_sec == t2->tv_sec && t1->tv_usec == t2->tv_usec;
}

static inline void
tv_delta (struct timeval *dest, const struct timeval *t1, const struct timeval *t2)
{
  int sec = t2->tv_sec - t1->tv_sec;
  int usec = t2->tv_usec - t1->tv_usec;

  while (usec < 0)
    {
      usec += 1000000;
      sec -= 1;
    }

  if (sec < 0)
    usec = sec = 0;

  dest->tv_sec = sec;
  dest->tv_usec = usec;
}

#define TV_WITHIN_SIGMA_MAX_SEC 600
#define TV_WITHIN_SIGMA_MAX_USEC (TV_WITHIN_SIGMA_MAX_SEC * 1000000)

/*
 * Is t1 and t2 within sigma microseconds of each other?
 */
static inline bool
tv_within_sigma (const struct timeval *t1, const struct timeval *t2, unsigned int sigma)
{
  const int delta = tv_subtract (t1, t2, TV_WITHIN_SIGMA_MAX_SEC); /* sigma should be less than 10 minutes */
  return -(int)sigma <= delta && delta <= (int)sigma;
}

/*
 * Used to determine in how many seconds we should be
 * called again.
 */
static inline void
interval_earliest_wakeup (interval_t *wakeup, time_t at, time_t current) {
  if (at > current)
    {
      const interval_t delta = (interval_t) (at - current);
      if (delta < *wakeup)
	*wakeup = delta;
      if (*wakeup < 0)
	*wakeup = 0;
    }
}

#endif