/*

   test_tio.c - simple test for the tio module

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

   Copyright (C) 2007, 2008, 2011, 2012, 2013 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 <string.h>

#include <assert.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <pthread.h>

#ifdef HAVE_STDINT_H

#include <stdint.h>

#endif /* HAVE_STDINT_H */

#include <stdlib.h>

#include <errno.h>

#include <unistd.h>

#include <fcntl.h>

#include "common.h"

#include "common/tio.h"

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

#ifndef ETIME

#define ETIME ETIMEDOUT

#endif /* ETIME */

/* structure for passing arguments to helper (is a thread) */

struct helper_args {

  int fd;

  size_t blocksize;

  size_t blocks;

  int timeout;

};

static void *help_tiowriter(void *arg)

{

  TFILE *fp;

  size_t i, j, k;

  uint8_t *buf;

  struct helper_args *hargs = (struct helper_args *)arg;

  /* allocate the buffer */

  buf = (uint8_t *)malloc(hargs->blocksize);

  assert(buf != NULL);

  /* open the file */

  fp = tio_fdopen(hargs->fd, hargs->timeout * 1000, hargs->timeout * 1000,

                  4 * 1024, 8 * 1024, 4 * 1024, 8 * 1024);

  assertok(fp != NULL);

  /* write the blocks */

  i = 0;

  for (k = 0; k < hargs->blocks; k++)

  {

    /* fill the buffer */

    for (j = 0; j < hargs->blocksize; j++)

      buf[j] = i++;

    assertok(tio_write(fp, buf, hargs->blocksize) == 0);

  }

  /* close the file flushing the buffer */

  assertok(tio_close(fp) == 0);

  /* we're done */

  free(buf);

  return NULL;

}

static void *help_tioreader(void *arg)

{

  TFILE *fp;

  size_t i, j, k;

  uint8_t *buf;

  struct helper_args *hargs = (struct helper_args *)arg;

  /* allocate the buffer */

  buf = (uint8_t *)malloc(hargs->blocksize);

  assert(buf != NULL);

  /* open the file */

  fp = tio_fdopen(hargs->fd, hargs->timeout * 1000, hargs->timeout * 1000,

                  4 * 1024, 8 * 1024, 4 * 1024, 8 * 1024);

  assertok(fp != NULL);

  /* read the blocks */

  i = 0;

  for (k = 0; k < hargs->blocks; k++)

  {

    assertok(tio_read(fp, buf, hargs->blocksize) == 0);

    /* check the buffer */

    for (j = 0; j < hargs->blocksize; j++)

      assert(buf[j] == (uint8_t)(i++));

  }

  /* close the file */

  assertok(tio_close(fp) == 0);

  /* we're done */

  free(buf);

  return NULL;

}

static void *help_normwriter(void *arg)

{

  FILE *fp;

  size_t i, j, k;

  uint8_t *buf;

  struct helper_args *hargs = (struct helper_args *)arg;

  /* allocate the buffer */

  buf = (uint8_t *)malloc(hargs->blocksize);

  assert(buf != NULL);

  /* open the file */

  fp = fdopen(hargs->fd, "wb");

  assertok(fp != NULL);

  /* write the blocks */

  i = 0;

  for (k = 0; k < hargs->blocks; k++)

  {

    /* fill the buffer */

    for (j = 0; j < hargs->blocksize; j++)

      buf[j] = i++;

    assertok(fwrite(buf, hargs->blocksize, 1, fp) == 1);

  }

  /* close the file flushing the buffer */

  assertok(fclose(fp) == 0);

  /* we're done */

  free(buf);

  return NULL;

}

static void *help_normreader(void *arg)

{

  FILE *fp;

  size_t i, j, k;

  struct helper_args *hargs = (struct helper_args *)arg;

  /* open the file */

  fp = fdopen(hargs->fd, "rb");

  assertok(fp != NULL);

  /* read the blocks */

  i = 0;

  for (k = 0; k < hargs->blocks; k++)

  {

    /* check the buffer */

    for (j = 0; j < hargs->blocksize; j++)

      assertok(fgetc(fp) == (uint8_t)(i++));

  }

  /* close the file */

  assertok(fclose(fp) == 0);

  return NULL;

}

/*

TODO: test timeout

TODO: test whether a simple request/response works

*/

static int test_blocks(size_t wbs, size_t wbl, size_t rbs, size_t rbl)

{

  int sp[2];

  pthread_t wthread, rthread;

  struct helper_args wargs, rargs;

  /* set up the socket pair */

  assertok(socketpair(AF_UNIX, SOCK_STREAM, 0, sp) == 0);

  /* log */

  printf("test_tio: writing %d blocks of %d bytes (%d total)\n",

         (int)wbl, (int)wbs, (int)(wbl * wbs));

  printf("test_tio: reading %d blocks of %d bytes (%d total)\n",

         (int)rbl, (int)rbs, (int)(rbl * rbs));

  /* start the writer thread */

  wargs.fd = sp[0];

  wargs.blocksize = wbs;

  wargs.blocks = wbl;

  wargs.timeout = 2;

  assertok(pthread_create(&wthread, NULL, help_tiowriter, &wargs) == 0);

/*  sleep(1); */

  /* start the reader thread */

  rargs.fd = sp[1];

  rargs.blocksize = rbs;

  rargs.blocks = rbl;

  rargs.timeout = 2;

  assertok(pthread_create(&rthread, NULL, help_tioreader, &rargs) == 0);

  /* wait for all threads to die */

  assertok(pthread_join(wthread, NULL) == 0);

  assertok(pthread_join(rthread, NULL) == 0);

  /* we're done */

  return 0;

}

static void test_reset(void)

{

  int sp[2];

  pthread_t wthread;

  struct helper_args wargs;

  TFILE *fp;

  size_t i, j, k, save;

  uint8_t buf[20];

  /* set up the socket pair */

  assertok(socketpair(AF_UNIX, SOCK_STREAM, 0, sp) == 0);

  /* start the writer thread */

  wargs.fd = sp[0];

  wargs.blocksize = 4 * 1024;

  wargs.blocks = 10;

  wargs.timeout = 2;

  assertok(pthread_create(&wthread, NULL, help_normwriter, &wargs) == 0);

  /* set up read handle */

  fp = tio_fdopen(sp[1], 2000, 2000, 2 * 1024, 4 * 1024, 2 * 1024, 4 * 1024);

  assertok(fp != NULL);

  /* perform 20 reads */

  i = 0;

  for (k = 0; k < 20; k++)

  {

    assertok(tio_read(fp, buf, sizeof(buf)) == 0);

    /* check the buffer */

    for (j = 0; j < sizeof(buf); j++)

      assert(buf[j] == (uint8_t)(i++));

  }

  /* mark and perform another 2 reads */

  tio_mark(fp);

  save = i;

  for (k = 20; k < 22; k++)

  {

    assertok(tio_read(fp, buf, sizeof(buf)) == 0);

    /* check the buffer */

    for (j = 0; j < sizeof(buf); j++)

      assert(buf[j] == (uint8_t)(i++));

  }

  /* check that we can reset */

  assertok(tio_reset(fp) == 0);

  /* perform 204 reads (partially the same as before) */

  i = save;

  for (k = 20; k < 224; k++)

  {

    assert(tio_read(fp, buf, sizeof(buf)) == 0);

    /* check the buffer */

    for (j = 0; j < sizeof(buf); j++)

      assert(buf[j] == (uint8_t)(i++));

  }

  /* check that we can reset */

  assertok(tio_reset(fp) == 0);

  /* perform 502 reads (partially the same) */

  i = save;

  for (k = 20; k < 522; k++)

  {

    assert(tio_read(fp, buf, sizeof(buf)) == 0);

    /* check the buffer */

    for (j = 0; j < sizeof(buf); j++)

      assert(buf[j] == (uint8_t)(i++));

  }

  /* check that reset is no longer possible */

  assertok(tio_reset(fp) != 0);

  /* read the remainder of the data 1526 reads */

  for (k = 522; k < 2048; k++)

  {

    assertok(tio_read(fp, buf, sizeof(buf)) == 0);

    /* check the buffer */

    for (j = 0; j < sizeof(buf); j++)

      assert(buf[j] == (uint8_t)(i++));

  }

  /* close the file */

  assertok(tio_close(fp) == 0);

  /* wait for the writer thread to die */

  assertok(pthread_join(wthread, NULL) == 0);

}

/* this test starts a reader and writer and does not write for a while */

static void test_timeout_reader(void)

{

  int sp[2];

  TFILE *rfp;

  FILE *wfp;

  uint8_t buf[20];

  time_t start, end;

  int saved_errno;

  /* set up the socket pair */

  assertok(socketpair(AF_UNIX, SOCK_STREAM, 0, sp) == 0);

  /* open the writer */

  assertok((wfp = fdopen(sp[0], "wb")) != NULL);

  /* open the reader */

  assertok((rfp = tio_fdopen(sp[1], 1100, 1100, 2 * 1024, 4 * 1024, 2 * 1024, 4 * 1024)) != NULL);

  printf("test_tio: test_timeout_reader: trying to read a block of %d bytes\n",

         (int)sizeof(buf));

  /* perform a read */

  start = time(NULL);

  errno = 0;

  assertok(tio_read(rfp, buf, sizeof(buf)) != 0);

  saved_errno = errno;

  end = time(NULL);

  printf("test_tio: test_timeout_reader: read 0 blocks of %d bytes in %d second(s) (%s)\n",

         (int)sizeof(buf), (int)(end - start), strerror(saved_errno));

  /* since the read timeout is more than a second end time should be bigger

     than start time */

  assert(end > start);

  /* the error should be timeout */

  assert(saved_errno == ETIME);

  /* close the files */

  assertok(tio_close(rfp) == 0);

  assertok(fclose(wfp) == 0);

}

/* this test starts a writer and an idle reader */

static void test_timeout_writer(void)

{

  int sp[2];

  FILE *rfp;

  TFILE *wfp;

  int i;

  uint8_t buf[20];

  time_t start, end;

  int numblocks = 10000;

  int saved_errno;

  /* set up the socket pair */

  assertok(socketpair(AF_UNIX, SOCK_STREAM, 0, sp) == 0);

  /* open the reader */

  assertok((rfp = fdopen(sp[0], "rb")) != NULL);

  /* open the writer */

  assertok((wfp = tio_fdopen(sp[1], 1100, 1100, 2 * 1024, 4 * 1024,

                             2 * sizeof(buf), 4 * sizeof(buf) + 1)) != NULL);

  printf("test_tio: test_timeout_writer: trying to write %d blocks of %d bytes\n",

         numblocks, (int)sizeof(buf));

  /* we perform a number of writes to the stream to see if they are buffered */

  start = time(NULL);

  errno = 0;

  for (i = 0; (i < numblocks) && (tio_write(wfp, buf, sizeof(buf)) == 0); i++)

    /* nothing */ ;

  saved_errno = errno;

  end = time(NULL);

  printf("test_tio: test_timeout_writer: written %d blocks of %d bytes in %d second(s) (%s)\n",

       i, (int)sizeof(buf), (int)(end - start), strerror(saved_errno));

  /* at the very least 4 writes should be OK because they filled the tio buffer */

  assert(i >= 4);

  /* but at a certain point the writes should have failed */

  assert(i < numblocks);

  /* since the write timeout is more than a second end time should be bigger

     than start time */

  assert(end > start);

  /* the error should be timeout */

  assert(saved_errno == ETIME);

  /* close the files */

  assertok(tio_close(wfp) != 0); /* fails because of bufferred data */

  assertok(fclose(rfp) == 0);

}

/* the main program... */

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

{

  /* normal read-writes */

  test_blocks(400, 11, 11, 400);

  test_blocks(10 * 1024, 11, 10 * 11, 1024);

  test_blocks(5 * 1023, 20, 20 * 1023, 5);

  /* reader closes file sooner */

/*  test_blocks(2 * 6 * 1023, 20, 20 * 1023, 5); */

/*  test_blocks(10, 10, 10, 9); */

  /* writer closes file sooner */

/*  test_blocks(4 * 1023, 20, 20 * 1023, 5); */

/*  test_blocks(10, 9, 10, 10); */

  /* set tio_mark() and tio_reset() functions */

  test_reset();

  /* test timeout functionality */

  test_timeout_reader();

  test_timeout_writer();

  return 0;

}