/*

   tio.c - timed io functions

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

   Copyright (C) 2007-2014 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"

#ifdef HAVE_STDINT_H

#include <stdint.h>

#endif /* HAVE_STDINT_H */

#include <stdlib.h>

#include <unistd.h>

#include <sys/time.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <errno.h>

#include <string.h>

#include <signal.h>

#include <stdio.h>

#include <limits.h>

#include <poll.h>

#include <time.h>

#include "tio.h"

/* for platforms that don't have ETIME use ETIMEDOUT */

#ifndef ETIME

#define ETIME ETIMEDOUT

#endif /* ETIME */

/* structure that holds a buffer

   the buffer contains the data that is between the application and the

   file descriptor that is used for efficient transfer

   the buffer is built up as follows:

   |.....********......|

         ^start        ^size

         ^--len--^           */

struct tio_buffer {

  uint8_t *buffer;

  size_t size;      /* the size of the buffer */

  size_t maxsize;   /* the maximum size of the buffer */

  size_t start;     /* the start of the data (before start is unused) */

  size_t len;       /* size of the data (from the start) */

};

/* structure that holds all the state for files */

struct tio_fileinfo {

  int fd;

  struct tio_buffer readbuffer;

  struct tio_buffer writebuffer;

  int readtimeout;

  int writetimeout;

  int read_resettable; /* whether the tio_reset() function can be called */

#ifdef DEBUG_TIO_STATS

  /* this is used to collect statistics on the use of the streams

     and can be used to tune the buffer sizes */

  size_t byteswritten;

  size_t bytesread;

#endif /* DEBUG_TIO_STATS */

};

/* some older versions of Solaris don't provide CLOCK_MONOTONIC but do have

   a CLOCK_HIGHRES that has the same properties we need */

#ifndef CLOCK_MONOTONIC

#ifdef CLOCK_HIGHRES

#define CLOCK_MONOTONIC CLOCK_HIGHRES

#endif /* CLOCK_HIGHRES */

#endif /* not CLOCK_MONOTONIC */

/* update the timeout to the value that is remaining before the deadline

   returns the number of milliseconds before the deadline (or a negative

   value of the deadline has expired) */

static inline int tio_time_remaining(struct timespec *deadline, int timeout)

{

  struct timespec tv;

  /* if this is the first call, set the deadline and return the full time */

  if ((deadline->tv_sec == 0) && (deadline->tv_nsec == 0))

  {

    if (clock_gettime(CLOCK_MONOTONIC, deadline) == 0)

    {

      deadline->tv_sec += timeout / 1000;

      deadline->tv_nsec += (timeout % 1000) * 1000000;

    }

    return timeout;

  }

  /* get the current time (fall back to full time on error) */

  if (clock_gettime(CLOCK_MONOTONIC, &tv))

    return timeout;

  /* calculate time remaining in milliseconds */

  return (deadline->tv_sec - tv.tv_sec) * 1000 +

         (deadline->tv_nsec - tv.tv_nsec) / 1000000;

}

/* open a new TFILE based on the file descriptor */

TFILE *tio_fdopen(int fd, int readtimeout, int writetimeout,

                  size_t initreadsize, size_t maxreadsize,

                  size_t initwritesize, size_t maxwritesize)

{

  struct tio_fileinfo *fp;

  fp = (struct tio_fileinfo *)malloc(sizeof(struct tio_fileinfo));

  if (fp == NULL)

    return NULL;

  fp->fd = fd;

  /* initialize read buffer */

  fp->readbuffer.buffer = (uint8_t *)malloc(initreadsize);

  if (fp->readbuffer.buffer == NULL)

  {

    free(fp);

    return NULL;

  }

  fp->readbuffer.size = initreadsize;

  fp->readbuffer.maxsize = maxreadsize;

  fp->readbuffer.start = 0;

  fp->readbuffer.len = 0;

  /* initialize write buffer */

  fp->writebuffer.buffer = (uint8_t *)malloc(initwritesize);

  if (fp->writebuffer.buffer == NULL)

  {

    free(fp->readbuffer.buffer);

    free(fp);

    return NULL;

  }

  fp->writebuffer.size = initwritesize;

  fp->writebuffer.maxsize = maxwritesize;

  fp->writebuffer.start = 0;

  fp->writebuffer.len = 0;

  /* initialize other attributes */

  fp->readtimeout = readtimeout;

  fp->writetimeout = writetimeout;

  fp->read_resettable = 0;

#ifdef DEBUG_TIO_STATS

  fp->byteswritten = 0;

  fp->bytesread = 0;

#endif /* DEBUG_TIO_STATS */

  return fp;

}

/* wait for any activity on the specified file descriptor using

   the specified deadline */

static int tio_wait(int fd, short events, int timeout,

                    struct timespec *deadline)

{

  int t;

  struct pollfd fds[1];

  int rv;

  while (1)

  {

    fds[0].fd = fd;

    fds[0].events = events;

    /* figure out the time we need to wait */

    if ((t = tio_time_remaining(deadline, timeout)) < 0)

    {

      errno = ETIME;

      return -1;

    }

    /* sanitiy check for moving clock */

    if (t > timeout)

      t = timeout;

    /* wait for activity */

    rv = poll(fds, 1, t);

    if (rv > 0)

      return 0; /* we have activity */

    else if (rv == 0)

    {

      /* no file descriptors were available within the specified time */

      errno = ETIME;

      return -1;

    }

    else if ((errno != EINTR) && (errno != EAGAIN))

      /* some error ocurred */

      return -1;

    /* we just try again on EINTR or EAGAIN */

  }

}

/* do a read on the file descriptor, returning the data in the buffer

   if no data was read in the specified time an error is returned */

int tio_read(TFILE *fp, void *buf, size_t count)

{

  struct timespec deadline = {0, 0};

  int rv;

  uint8_t *tmp;

  size_t newsz;

  size_t len;

  /* have a more convenient storage type for the buffer */

  uint8_t *ptr = (uint8_t *)buf;

  /* loop until we have returned all the needed data */

  while (1)

  {

    /* check if we have enough data in the buffer */

    if (fp->readbuffer.len >= count)

    {

      if (count > 0)

      {

        if (ptr != NULL)

          memcpy(ptr, fp->readbuffer.buffer + fp->readbuffer.start, count);

        /* adjust buffer position */

        fp->readbuffer.start += count;

        fp->readbuffer.len -= count;

      }

      return 0;

    }

    /* empty what we have and continue from there */

    if (fp->readbuffer.len > 0)

    {

      if (ptr != NULL)

      {

        memcpy(ptr, fp->readbuffer.buffer + fp->readbuffer.start,

               fp->readbuffer.len);

        ptr += fp->readbuffer.len;

      }

      count -= fp->readbuffer.len;

      fp->readbuffer.start += fp->readbuffer.len;

      fp->readbuffer.len = 0;

    }

    /* after this point until the read fp->readbuffer.len is 0 */

    if (!fp->read_resettable)

    {

      /* the stream is not resettable, re-use the buffer */

      fp->readbuffer.start = 0;

    }

    else if (fp->readbuffer.start >= (fp->readbuffer.size - 4))

    {

      /* buffer is running empty, try to grow buffer */

      if (fp->readbuffer.size < fp->readbuffer.maxsize)

      {

        newsz = fp->readbuffer.size * 2;

        if (newsz > fp->readbuffer.maxsize)

          newsz = fp->readbuffer.maxsize;

        tmp = realloc(fp->readbuffer.buffer, newsz);

        if (tmp != NULL)

        {

          fp->readbuffer.buffer = tmp;

          fp->readbuffer.size = newsz;

        }

      }

      /* if buffer still does not contain enough room, clear resettable */

      if (fp->readbuffer.start >= (fp->readbuffer.size - 4))

      {

        fp->readbuffer.start = 0;

        fp->read_resettable = 0;

      }

    }

    /* wait until we have input */

    if (tio_wait(fp->fd, POLLIN, fp->readtimeout, &deadline))

      return -1;

    /* read the input in the buffer */

    len = fp->readbuffer.size - fp->readbuffer.start;

#ifdef SSIZE_MAX

    if (len > SSIZE_MAX)

      len = SSIZE_MAX;

#endif /* SSIZE_MAX */

    rv = read(fp->fd, fp->readbuffer.buffer + fp->readbuffer.start, len);

    /* check for errors */

    if (rv == 0)

    {

      errno = ECONNRESET;

      return -1;

    }

    else if ((rv < 0) && (errno != EINTR) && (errno != EAGAIN))

      return -1;        /* something went wrong with the read */

    else if (rv > 0)

      fp->readbuffer.len = rv;  /* skip the read part in the buffer */

#ifdef DEBUG_TIO_STATS

    fp->bytesread += rv;

#endif /* DEBUG_TIO_STATS */

  }

}

/* Read and discard the specified number of bytes from the stream. */

int tio_skip(TFILE *fp, size_t count)

{

  return tio_read(fp, NULL, count);

}

/* Read all available data from the stream and empty the read buffer. */

int tio_skipall(TFILE *fp, int timeout)

{

  struct timespec deadline = {0, 0};

  int rv;

  size_t len;

  /* clear the read buffer */

  fp->readbuffer.start = 0;

  fp->readbuffer.len = 0;

  fp->read_resettable = 0;

  /* read until we can't read no more */

  len = fp->readbuffer.size;

#ifdef SSIZE_MAX

  if (len > SSIZE_MAX)

    len = SSIZE_MAX;

#endif /* SSIZE_MAX */

  while (1)

  {

    /* wait until we have input */

    if (tio_wait(fp->fd, POLLIN, timeout, &deadline))

      return -1;

    /* read data from the stream */

    rv = read(fp->fd, fp->readbuffer.buffer, len);

    if (rv == 0)

      return 0; /* end-of-file */

    if ((rv < 0) && (errno == EWOULDBLOCK))

      return 0; /* we've ready everything we can without blocking */

    if ((rv < 0) && (errno != EINTR) && (errno != EAGAIN))

      return -1; /* something went wrong with the read */

  }

}

/* the caller has assured us that we can write to the file descriptor

   and we give it a shot */

static int tio_writebuf(TFILE *fp)

{

  int rv;

  /* write the buffer */

#ifdef MSG_NOSIGNAL

  rv = send(fp->fd, fp->writebuffer.buffer + fp->writebuffer.start,

            fp->writebuffer.len, MSG_NOSIGNAL);

#else /* not MSG_NOSIGNAL */

  /* on platforms that cannot use send() with masked signals, we change the

     signal mask and change it back after the write (note that there is a

     race condition here) */

  struct sigaction act, oldact;

  /* set up sigaction */

  memset(&act, 0, sizeof(struct sigaction));

  act.sa_sigaction = NULL;

  act.sa_handler = SIG_IGN;

  sigemptyset(&act.sa_mask);

  act.sa_flags = SA_RESTART;

  /* ignore SIGPIPE */

  if (sigaction(SIGPIPE, &act, &oldact) != 0)

    return -1; /* error setting signal handler */

  /* write the buffer */

  rv = write(fp->fd, fp->writebuffer.buffer + fp->writebuffer.start,

             fp->writebuffer.len);

  /* restore the old handler for SIGPIPE */

  if (sigaction(SIGPIPE, &oldact, NULL) != 0)

    return -1; /* error restoring signal handler */

#endif

  /* check for errors */

  if ((rv == 0) || ((rv < 0) && (errno != EINTR) && (errno != EAGAIN)))

    return -1; /* something went wrong with the write */

  /* skip the written part in the buffer */

  if (rv > 0)

  {

    fp->writebuffer.start += rv;

    fp->writebuffer.len -= rv;

#ifdef DEBUG_TIO_STATS

    fp->byteswritten += rv;

#endif /* DEBUG_TIO_STATS */

    /* reset start if len is 0 */

    if (fp->writebuffer.len == 0)

      fp->writebuffer.start = 0;

    /* move contents of the buffer to the front if it will save enough room */

    if (fp->writebuffer.start >= (fp->writebuffer.size / 4))

    {

      memmove(fp->writebuffer.buffer,

              fp->writebuffer.buffer + fp->writebuffer.start,

              fp->writebuffer.len);

      fp->writebuffer.start = 0;

    }

  }

  return 0;

}

/* write all the data in the buffer to the stream */

int tio_flush(TFILE *fp)

{

  struct timespec deadline = {0, 0};

  /* loop until we have written our buffer */

  while (fp->writebuffer.len > 0)

  {

    /* wait until we can write */

    if (tio_wait(fp->fd, POLLOUT, fp->writetimeout, &deadline))

      return -1;

    /* write one block */

    if (tio_writebuf(fp))

      return -1;

  }

  return 0;

}

/* try a single write of data in the buffer if the file descriptor

   will accept data */

static int tio_flush_nonblock(TFILE *fp)

{

  struct pollfd fds[1];

  int rv;

  /* see if we can write without blocking */

  fds[0].fd = fp->fd;

  fds[0].events = POLLOUT;

  rv = poll(fds, 1, 0);

  /* check if any file descriptors were ready (timeout) or we were

     interrupted */

  if ((rv == 0) || ((rv < 0) && ((errno == EINTR) || (errno == EAGAIN))))

    return 0;

  /* any other errors? */

  if (rv < 0)

    return -1;

  /* so file descriptor will accept writes */

  return tio_writebuf(fp);

}

int tio_write(TFILE *fp, const void *buf, size_t count)

{

  size_t fr;

  uint8_t *tmp;

  size_t newsz;

  const uint8_t *ptr = (const uint8_t *)buf;

  /* keep filling the buffer until we have bufferred everything */

  while (count > 0)

  {

    /* figure out free size in buffer */

    fr = fp->writebuffer.size - (fp->writebuffer.start + fp->writebuffer.len);

    if (count <= fr)

    {

      /* the data fits in the buffer */

      memcpy(fp->writebuffer.buffer + fp->writebuffer.start +

             fp->writebuffer.len, ptr, count);

      fp->writebuffer.len += count;

      return 0;

    }

    else if (fr > 0)

    {

      /* fill the buffer with data that will fit */

      memcpy(fp->writebuffer.buffer + fp->writebuffer.start +

             fp->writebuffer.len, ptr, fr);

      fp->writebuffer.len += fr;

      ptr += fr;

      count -= fr;

    }

    /* try to flush some of the data that is in the buffer */

    if (tio_flush_nonblock(fp))

      return -1;

    /* if we have room now, try again */

    if (fp->writebuffer.size > (fp->writebuffer.start + fp->writebuffer.len))

      continue;

    /* try to grow the buffer */

    if (fp->writebuffer.size < fp->writebuffer.maxsize)

    {

      newsz = fp->writebuffer.size * 2;

      if (newsz > fp->writebuffer.maxsize)

        newsz = fp->writebuffer.maxsize;

      tmp = realloc(fp->writebuffer.buffer, newsz);

      if (tmp != NULL)

      {

        fp->writebuffer.buffer = tmp;

        fp->writebuffer.size = newsz;

        continue; /* try again */

      }

    }

    /* write the buffer to the stream */

    if (tio_flush(fp))

      return -1;

  }

  return 0;

}

int tio_close(TFILE *fp)

{

  int retv;

  /* write any buffered data */

  retv = tio_flush(fp);

#ifdef DEBUG_TIO_STATS

  /* dump statistics to stderr */

  fprintf(stderr, "DEBUG_TIO_STATS READ=%lu WRITTEN=%lu\n",

          (unsigned long)fp->bytesread, (unsigned long)fp->byteswritten);

#endif /* DEBUG_TIO_STATS */

  /* close file descriptor */

  if (close(fp->fd))

    retv = -1;

  /* free any allocated buffers */

  memset(fp->readbuffer.buffer, 0, fp->readbuffer.size);

  memset(fp->writebuffer.buffer, 0, fp->writebuffer.size);

  free(fp->readbuffer.buffer);

  free(fp->writebuffer.buffer);

  /* free the tio struct itself */

  free(fp);

  /* return the result of the earlier operations */

  return retv;

}

void tio_mark(TFILE *fp)

{

  /* move any data in the buffer to the start of the buffer */

  if ((fp->readbuffer.start > 0) && (fp->readbuffer.len > 0))

  {

    memmove(fp->readbuffer.buffer,

            fp->readbuffer.buffer + fp->readbuffer.start, fp->readbuffer.len);

    fp->readbuffer.start = 0;

  }

  /* mark the stream as resettable */

  fp->read_resettable = 1;

}

int tio_reset(TFILE *fp)

{

  /* check if the stream is (still) resettable */

  if (!fp->read_resettable)

    return -1;

  /* reset the buffer */

  fp->readbuffer.len += fp->readbuffer.start;

  fp->readbuffer.start = 0;

  return 0;

}