/* Computing deadlines for timeouts.

   Copyright (C) 2017-2018 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   The GNU C 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.

   The GNU C 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 the GNU C Library; if not, see

   <http://www.gnu.org/licenses/>.  */

#include <net-internal.h>

#include <assert.h>

#include <limits.h>

#include <stdio.h>

#include <stdint.h>

#include <time.h>

struct deadline_current_time

__deadline_current_time (void)

{

  struct deadline_current_time result;

  if (__clock_gettime (CLOCK_MONOTONIC, &result.current) != 0)

    {

      struct timeval current_tv;

      if (__gettimeofday (&current_tv, NULL) == 0)

        __libc_fatal ("Fatal error: gettimeofday system call failed\n");

      result.current.tv_sec = current_tv.tv_sec;

      result.current.tv_nsec = current_tv.tv_usec * 1000;

    }

  assert (result.current.tv_sec >= 0);

  return result;

}

/* A special deadline value for which __deadline_is_infinite is

   true.  */

static inline struct deadline

infinite_deadline (void)

{

  return (struct deadline) { { -1, -1 } };

}

struct deadline

__deadline_from_timeval (struct deadline_current_time current,

                         struct timeval tv)

{

  assert (__is_timeval_valid_timeout (tv));

  /* Compute second-based deadline.  Perform the addition in

     uintmax_t, which is unsigned, to simply overflow detection.  */

  uintmax_t sec = current.current.tv_sec;

  sec += tv.tv_sec;

  if (sec < (uintmax_t) tv.tv_sec)

    return infinite_deadline ();

  /* Compute nanosecond deadline.  */

  int nsec = current.current.tv_nsec + tv.tv_usec * 1000;

  if (nsec >= 1000 * 1000 * 1000)

    {

      /* Carry nanosecond overflow to seconds.  */

      nsec -= 1000 * 1000 * 1000;

      if (sec + 1 < sec)

        return infinite_deadline ();

      ++sec;

    }

  /* This uses a GCC extension, otherwise these casts for detecting

     overflow would not be defined.  */

  if ((time_t) sec < 0 || sec != (uintmax_t) (time_t) sec)

    return infinite_deadline ();

  return (struct deadline) { { sec, nsec } };

}

int

__deadline_to_ms (struct deadline_current_time current,

                  struct deadline deadline)

{

  if (__deadline_is_infinite (deadline))

    return INT_MAX;

  if (current.current.tv_sec > deadline.absolute.tv_sec

      || (current.current.tv_sec == deadline.absolute.tv_sec

          && current.current.tv_nsec >= deadline.absolute.tv_nsec))

    return 0;

  time_t sec = deadline.absolute.tv_sec - current.current.tv_sec;

  if (sec >= INT_MAX)

    /* This value will overflow below.  */

    return INT_MAX;

  int nsec = deadline.absolute.tv_nsec - current.current.tv_nsec;

  if (nsec < 0)

    {

      /* Borrow from the seconds field.  */

      assert (sec > 0);

      --sec;

      nsec += 1000 * 1000 * 1000;

    }

  /* Prepare for rounding up to milliseconds.  */

  nsec += 999999;

  if (nsec > 1000 * 1000 * 1000)

    {

      assert (sec < INT_MAX);

      ++sec;

      nsec -= 1000 * 1000 * 1000;

    }

  unsigned int msec = nsec / (1000 * 1000);

  if (sec > INT_MAX / 1000)

    return INT_MAX;

  msec += sec * 1000;

  if (msec > INT_MAX)

    return INT_MAX;

  return msec;

}