/* Test driver for malloc interposition tests.

   Copyright (C) 2016-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; see the file COPYING.LIB.  If

   not, see <http://www.gnu.org/licenses/>.  */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#if INTERPOSE_THREADS

#include <pthread.h>

#endif

static int do_test (void);

#define TEST_FUNCTION do_test ()

#include "../test-skeleton.c"

/* Fills BUFFER with a test string.  */

static void

line_string (int number, char *buffer, size_t length)

{

  for (size_t i = 0; i < length - 2; ++i)

    buffer[i] = 'A' + ((number + i) % 26);

  buffer[length - 2] = '\n';

  buffer[length - 1] = '\0';

}

/* Perform the tests.  */

static void *

run_tests (void *closure)

{

  char *temp_file_path;

  int fd = create_temp_file ("tst-malloc-interpose", &temp_file_path);

  if (fd < 0)

    _exit (1);

  /* Line lengths excluding the line terminator.  */

  static const int line_lengths[] = { 0, 45, 80, 2, 8201, 0, 17, -1 };

  /* Fill the test file with data.  */

  {

    FILE *fp = fdopen (fd, "w");

    for (int lineno = 0; line_lengths[lineno] >= 0; ++lineno)

      {

        char buffer[line_lengths[lineno] + 2];

        line_string (lineno, buffer, sizeof (buffer));

        fprintf (fp, "%s", buffer);

      }

    if (ferror (fp))

      {

        printf ("error: fprintf: %m\n");

        _exit (1);

      }

    if (fclose (fp) != 0)

      {

        printf ("error: fclose: %m\n");

        _exit (1);

      }

  }

  /* Read the test file.  This tests libc-internal allocation with

     realloc.  */

  {

    FILE *fp = fopen (temp_file_path, "r");

    char *actual = NULL;

    size_t actual_size = 0;

    for (int lineno = 0; ; ++lineno)

      {

        errno = 0;

        ssize_t result = getline (&actual, &actual_size, fp);

        if (result == 0)

          {

            printf ("error: invalid return value 0 from getline\n");

            _exit (1);

          }

        if (result < 0 && errno != 0)

          {

            printf ("error: getline: %m\n");

            _exit (1);

          }

        if (result < 0 && line_lengths[lineno] >= 0)

          {

            printf ("error: unexpected end of file after line %d\n", lineno);

            _exit (1);

          }

        if (result > 0 && line_lengths[lineno] < 0)

          {

            printf ("error: no end of file after line %d\n", lineno);

            _exit (1);

          }

        if (result == -1 && line_lengths[lineno] == -1)

          /* End of file reached as expected.  */

          break;

        if (result != line_lengths[lineno] + 1)

          {

            printf ("error: line length mismatch: expected %d, got %zd\n",

                    line_lengths[lineno], result);

            _exit (1);

          }

        char expected[line_lengths[lineno] + 2];

        line_string (lineno, expected, sizeof (expected));

        if (strcmp (actual, expected) != 0)

          {

            printf ("error: line mismatch\n");

            printf ("error:   expected: [[%s]]\n", expected);

            printf ("error:   actual:   [[%s]]\n", actual);

            _exit (1);

          }

      }

    if (fclose (fp) != 0)

      {

        printf ("error: fclose (after reading): %m\n");

        _exit (1);

      }

  }

  free (temp_file_path);

  /* Make sure that fork is working.  */

  pid_t pid = fork ();

  if (pid == -1)

    {

      printf ("error: fork: %m\n");

      _exit (1);

    }

  enum { exit_code = 55 };

  if (pid == 0)

    _exit (exit_code);

  int status;

  int ret = waitpid (pid, &status, 0);

  if (ret < 0)

    {

      printf ("error: waitpid: %m\n");

      _exit (1);

    }

  if (!WIFEXITED (status) || WEXITSTATUS (status) != exit_code)

    {

      printf ("error: unexpected exit status from child process: %d\n",

              status);

      _exit (1);

    }

  return NULL;

}

/* This is used to detect if malloc has not been successfully

   interposed.  The interposed malloc does not use brk/sbrk.  */

static void *initial_brk;

__attribute__ ((constructor))

static void

set_initial_brk (void)

{

  initial_brk = sbrk (0);

}

/* Terminate the process if the break value has been changed.  */

__attribute__ ((destructor))

static void

check_brk (void)

{

  void *current = sbrk (0);

  if (current != initial_brk)

    {

      printf ("error: brk changed from %p to %p; no interposition?\n",

              initial_brk, current);

      _exit (1);

    }

}

static int

do_test (void)

{

  check_brk ();

#if INTERPOSE_THREADS

  pthread_t thr = xpthread_create (NULL, run_tests, NULL);

  xpthread_join (thr);

#else

  run_tests (NULL);

#endif

  check_brk ();

  return 0;

}