/*

   test_clock.c - tests for finding usable system clocks

   This file is part of the nss-pam-ldapd library.

   Copyright (C) 2013-2015 Arthur de Jong

   This library is free software; you can redistribute it and/or

   modify it under the terms of the GNU Lesser General Public

   License as published by the Free Software Foundation; either

   version 2.1 of the License, or (at your option) any later version.

   This library 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

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with this library; if not, write to the Free Software

   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

   02110-1301 USA

*/

#include "config.h"

#include <stdio.h>

#include <assert.h>

#include <time.h>

#include <errno.h>

#include <string.h>

#include <stdlib.h>

#include "compat/attrs.h"

/* use clock_gettime() to see if the specified clock is supported */

static int test_clock_gettime(clockid_t c, const char *cname)

{

  struct timespec t1 = {0, 0};

  struct timespec t2 = {0, 0};

  struct timespec t3 = {0, 50 * 1000 * 1000}; /* 50 msec */

  struct timespec t4 = {0, 0};

  long diff;

  int result = 0;

  /* see if we can get resolution (not important so ignore any failures) */

  errno = 0;

  if (clock_getres(c, &t1))

    printf("     clock %s resolution not supported: %s\n", cname, strerror(errno));

  if ((t1.tv_sec != 0) || (t1.tv_nsec != 0))

    printf("     clock %s resolution: %ld.%09ld\n", cname, (long)t1.tv_sec, (long)t1.tv_nsec);

  /* see if we can get the time */

  errno = 0;

  if (clock_gettime(c, &t2))

  {

    printf("FAIL clock %s get time not supported: %s\n",

           cname, strerror(errno));

    if ((t2.tv_sec != 0) || (t2.tv_nsec != 0))

      printf("     clock %s time: %ld.%09ld\n", cname, (long)t2.tv_sec, (long)t2.tv_nsec);

    return -1;

  }

  else

    printf("OK   clock %s time: %ld.%09ld\n", cname, (long)t2.tv_sec, (long)t2.tv_nsec);

  /* quick sleep (assume we're not interrupted) */

  (void)nanosleep(&t3, NULL);

  /* see if we can get the time again */

  errno = 0;

  if (clock_gettime(c, &t4))

  {

    printf("FAIL clock %s get time twice not supported: %s\n",

           cname, strerror(errno));

    if ((t4.tv_sec != 0) || (t4.tv_nsec != 0))

      printf("     clock %s time: %ld.%09ld\n", cname, (long)t4.tv_sec, (long)t4.tv_nsec);

    return -1;

  }

  else

    printf("OK   clock %s time: %ld.%09ld\n", cname, (long)t4.tv_sec, (long)t4.tv_nsec);

  /* calculate difference */

  diff = ((long)t4.tv_sec - (long)t2.tv_sec - (long)t3.tv_sec) * 1000000000L +

         ((long)t4.tv_nsec - (long)t2.tv_nsec - (long)t3.tv_nsec);

  if ((diff < (-10 * 1000 * 1000)) || (diff > (20 * 1000 * 1000)))

  {

    result = -1;

    printf("FAIL ");

  }

  else

    printf("OK   ");

  printf("clock %s time diff: %s%ld.%09ld %.1f%%\n", cname, (diff < 0) ? "-" : "",

         (labs(diff) / 1000000000L), (labs(diff) % 1000000000L),

         (float)labs(diff) / (float)((long)t3.tv_sec * 10000000L + (long)t3.tv_nsec / 100));

  return result;

}

/* wrapper for test_clock_gettime() that passes the clock name */

#define TEST_CLOCK_GETTIME(clock) test_clock_gettime(clock, #clock)

int main(int UNUSED(argc), char UNUSED(*argv[]))

{

  int found_clocks = 0;

#ifdef CLOCK_MONOTONIC_RAW

  if (!TEST_CLOCK_GETTIME(CLOCK_MONOTONIC_RAW))

    found_clocks++;

#endif

#ifdef CLOCK_MONOTONIC_FAST

  if (!TEST_CLOCK_GETTIME(CLOCK_MONOTONIC_FAST))

    found_clocks++;

#endif

#ifdef CLOCK_MONOTONIC_COARSE

  if (!TEST_CLOCK_GETTIME(CLOCK_MONOTONIC_COARSE))

    found_clocks++;

#endif

#ifdef CLOCK_MONOTONIC

  if (!TEST_CLOCK_GETTIME(CLOCK_MONOTONIC))

    found_clocks++;

#endif

#ifdef CLOCK_UPTIME_FAST

  if (!TEST_CLOCK_GETTIME(CLOCK_UPTIME_FAST))

    found_clocks++;

#endif

#ifdef CLOCK_UPTIME

  if (!TEST_CLOCK_GETTIME(CLOCK_UPTIME))

    found_clocks++;

#endif

#ifdef CLOCK_BOOTTIME

  if (!TEST_CLOCK_GETTIME(CLOCK_BOOTTIME))

    found_clocks++;

#endif

#ifdef CLOCK_MONOTONIC_PRECISE

  if (!TEST_CLOCK_GETTIME(CLOCK_MONOTONIC_PRECISE))

    found_clocks++;

#endif

#ifdef CLOCK_UPTIME_PRECISE

  if (!TEST_CLOCK_GETTIME(CLOCK_UPTIME_PRECISE))

    found_clocks++;

#endif

#ifdef CLOCK_HIGHRES

#if CLOCK_HIGHRES == CLOCK_MONOTONIC

  printf("     CLOCK_HIGHRES == CLOCK_MONOTONIC\n");

#else

  /* for Solaris, should be similar to CLOCK_MONOTONIC (it may be an alias) */

  if (!TEST_CLOCK_GETTIME(CLOCK_HIGHRES))

    found_clocks++;

#endif

#endif

#ifdef CLOCK_REALTIME_FAST

  if (!TEST_CLOCK_GETTIME(CLOCK_REALTIME_FAST))

    found_clocks++;

#endif

#ifdef CLOCK_REALTIME_COARSE

  if (!TEST_CLOCK_GETTIME(CLOCK_REALTIME_COARSE))

    found_clocks++;

#endif

  if (!TEST_CLOCK_GETTIME(CLOCK_REALTIME))

    found_clocks++;

#ifdef CLOCK_REALTIME_PRECISE

  if (!TEST_CLOCK_GETTIME(CLOCK_REALTIME_PRECISE))

    found_clocks++;

#endif

  printf("%d usable clocks found\n", found_clocks);

  return !(found_clocks > 0);

}