/* Test offsets in files being read, in particular with ungetc.
   Copyright (C) 2025 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
   <https://www.gnu.org/licenses/>.  */

#include <dlfcn.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <support/check.h>
#include <support/temp_file.h>
#include <support/xstdio.h>
#include <support/xunistd.h>

static volatile bool fail = false;

/* Induce a malloc failure whenever FAIL is set.  */
void *
malloc (size_t sz)
{
  if (fail)
    return NULL;

  static void *(*real_malloc) (size_t);

  if (real_malloc == NULL)
    real_malloc = dlsym (RTLD_NEXT, "malloc");

  return real_malloc (sz);
}

/* The name of the temporary file used by all the tests.  */
static char *filename;

/* st_blksize value for that file, or BUFSIZ if out of range.  */
static int blksize = BUFSIZ;

/* Test data, both written to that file and used as an in-memory
   stream.  */
char test_data[2 * BUFSIZ];

/* Ways to open a test stream for reading (that may use different code
   paths in libio).  */
enum test_open_case
  {
    test_open_fopen,
    test_open_fopen_m,
    test_open_fopen64,
    test_open_fopen64_m,
    test_open_fmemopen,
    test_open_max
  };

static const char *const test_open_case_name[test_open_max] =
  {
    "fopen", "fopen(mmap)", "fopen64", "fopen64(mmap)", "fmemopen"
  };

static FILE *
open_test_stream (enum test_open_case c)
{
  FILE *fp;
  switch (c)
    {
    case test_open_fopen:
      fp = fopen (filename, "r");
      break;

    case test_open_fopen_m:
      fp = fopen (filename, "rm");
      break;

    case test_open_fopen64:
      fp = fopen64 (filename, "r");
      break;

    case test_open_fopen64_m:
      fp = fopen64 (filename, "rm");
      break;

    case test_open_fmemopen:
      fp = fmemopen (test_data, 2 * BUFSIZ, "r");
      break;

    default:
      abort ();
    }
  TEST_VERIFY_EXIT (fp != NULL);
  return fp;
}

/* Base locations at which the main test (ungetc calls then doing
   something that clears ungetc characters, then checking offset)
   starts.  */
enum test_base_loc
  {
    base_loc_start,
    base_loc_blksize,
    base_loc_half,
    base_loc_bufsiz,
    base_loc_eof,
    base_loc_max
  };

static int
base_loc_to_bytes (enum test_base_loc loc, int offset)
{
  switch (loc)
    {
    case base_loc_start:
      return offset;

    case base_loc_blksize:
      return blksize + offset;

    case base_loc_half:
      return BUFSIZ / 2 + offset;

    case base_loc_bufsiz:
      return BUFSIZ + offset;

    case base_loc_eof:
      return 2 * BUFSIZ + offset;

    default:
      abort ();
    }
}

/* Ways to clear data from ungetc.  */
enum clear_ungetc_case
  {
    clear_fseek,
    clear_fseekm1,
    clear_fseekp1,
    clear_fseeko,
    clear_fseekom1,
    clear_fseekop1,
    clear_fseeko64,
    clear_fseeko64m1,
    clear_fseeko64p1,
    clear_fsetpos,
    clear_fsetposu,
    clear_fsetpos64,
    clear_fsetpos64u,
    clear_fflush,
    clear_fflush_null,
    clear_fclose,
    clear_max
  };

static const char *const clear_ungetc_case_name[clear_max] =
  {
    "fseek", "fseek(-1)", "fseek(1)", "fseeko", "fseeko(-1)", "fseeko(1)",
    "fseeko64", "fseeko64(-1)", "fseeko64(1)", "fsetpos", "fsetpos(before)",
    "fsetpos64", "fsetpos64(before)", "fflush", "fflush(NULL)", "fclose"
  };

static int
clear_offset (enum clear_ungetc_case c, int num_ungetc)
{
  switch (c)
    {
    case clear_fseekm1:
    case clear_fseekom1:
    case clear_fseeko64m1:
      return -1;

    case clear_fseekp1:
    case clear_fseekop1:
    case clear_fseeko64p1:
      return 1;

    case clear_fsetposu:
    case clear_fsetpos64u:
      return num_ungetc;

    default:
      return 0;
    }
}

/* The offsets used with fsetpos / fsetpos64.  */
static fpos_t pos;
static fpos64_t pos64;

static int
do_clear_ungetc (FILE *fp, enum clear_ungetc_case c, int num_ungetc)
{
  int ret;
  int offset = clear_offset (c, num_ungetc);
  switch (c)
    {
    case clear_fseek:
    case clear_fseekm1:
    case clear_fseekp1:
      ret = fseek (fp, offset, SEEK_CUR);
      break;

    case clear_fseeko:
    case clear_fseekom1:
    case clear_fseekop1:
      ret = fseeko (fp, offset, SEEK_CUR);
      break;

    case clear_fseeko64:
    case clear_fseeko64m1:
    case clear_fseeko64p1:
      ret = fseeko64 (fp, offset, SEEK_CUR);
      break;

    case clear_fsetpos:
    case clear_fsetposu:
      ret = fsetpos (fp, &pos);
      break;

    case clear_fsetpos64:
    case clear_fsetpos64u:
      ret = fsetpos64 (fp, &pos64);
      break;

    case clear_fflush:
      ret = fflush (fp);
      break;

    case clear_fflush_null:
      ret = fflush (NULL);
      break;

    case clear_fclose:
      ret = fclose (fp);
      break;

    default:
      abort();
    }
  TEST_COMPARE (ret, 0);
  return offset;
}

static bool
clear_valid (enum test_open_case c, enum clear_ungetc_case cl)
{
  switch (c)
    {
    case test_open_fmemopen:
      /* fflush is not valid for input memory streams, and fclose is
	 useless for this test for such streams because there is no
	 underlying open file description for which an offset could be
	 checked after fclose.  */
      switch (cl)
	{
	case clear_fflush:
	case clear_fflush_null:
	case clear_fclose:
	  return false;

	default:
	  return true;
	}

    default:
      /* All ways of clearing ungetc state are valid for streams with
	 an underlying file.  */
      return true;
    }
}

static bool
clear_closes_file (enum clear_ungetc_case cl)
{
  switch (cl)
    {
    case clear_fclose:
      return true;

    default:
      return false;
    }
}

static void
clear_getpos_before (FILE *fp, enum clear_ungetc_case c)
{
  switch (c)
    {
    case clear_fsetposu:
      TEST_COMPARE (fgetpos (fp, &pos), 0);
      break;

    case clear_fsetpos64u:
      TEST_COMPARE (fgetpos64 (fp, &pos64), 0);
      break;

    default:
      break;
    }
}

static void
clear_getpos_after (FILE *fp, enum clear_ungetc_case c)
{
  switch (c)
    {
    case clear_fsetpos:
      TEST_COMPARE (fgetpos (fp, &pos), 0);
      break;

    case clear_fsetpos64:
      TEST_COMPARE (fgetpos64 (fp, &pos64), 0);
      break;

    default:
      break;
    }
}

/* Ways to verify results of clearing ungetc data.  */
enum verify_case
  {
    verify_read,
    verify_ftell,
    verify_ftello,
    verify_ftello64,
    verify_fd,
    verify_max
  };

static const char *const verify_case_name[verify_max] =
  {
    "read", "ftell", "ftello", "ftello64", "fd"
  };

static bool
valid_fd_offset (enum test_open_case c, enum clear_ungetc_case cl)
{
  switch (c)
    {
    case test_open_fmemopen:
      /* No open file description.  */
      return false;

    default:
      /* fseek does not necessarily set the offset for the underlying
	 open file description ("If the most recent operation, other
	 than ftell(), on a given stream is fflush(), the file offset
	 in the underlying open file description shall be adjusted to
	 reflect the location specified by fseek()." in POSIX does not
	 include the case here where getc was the last operation).
	 Similarly, fsetpos does not necessarily set that offset
	 either.  */
      switch (cl)
	{
	case clear_fflush:
	case clear_fflush_null:
	case clear_fclose:
	  return true;

	default:
	  return false;
	}
    }
}

static bool
verify_valid (enum test_open_case c, enum clear_ungetc_case cl,
	      enum verify_case v)
{
  switch (v)
    {
    case verify_fd:
      return valid_fd_offset (c, cl);

    default:
      switch (cl)
	{
	case clear_fclose:
	  return false;

	default:
	  return true;
	}
    }
}

static bool
verify_uses_fd (enum verify_case v)
{
  switch (v)
    {
    case verify_fd:
      return true;

    default:
      return false;
    }
}

static int
read_to_test_loc (FILE *fp, enum test_base_loc loc, int offset)
{
  int to_read = base_loc_to_bytes (loc, offset);
  for (int i = 0; i < to_read; i++)
    TEST_COMPARE (getc (fp), (unsigned char) i);
  return to_read;
}

static void
setup (void)
{
  int fd = create_temp_file ("tst-read-offset", &filename);
  TEST_VERIFY_EXIT (fd != -1);
  struct stat64 st;
  xfstat64 (fd, &st);
  if (st.st_blksize > 0 && st.st_blksize < BUFSIZ)
    blksize = st.st_blksize;
  printf ("BUFSIZ = %d, blksize = %d\n", BUFSIZ, blksize);
  xclose (fd);
  FILE *fp = xfopen (filename, "w");
  for (size_t i = 0; i < 2 * BUFSIZ; i++)
    {
      unsigned char c = i;
      TEST_VERIFY_EXIT (fputc (c, fp) == c);
      test_data[i] = c;
    }
  xfclose (fp);
}

static void
test_one_case (enum test_open_case c, enum test_base_loc loc, int offset,
	       int num_ungetc, int num_ungetc_diff, bool ungetc_fallback,
	       enum clear_ungetc_case cl, enum verify_case v)
{
  int full_offset = base_loc_to_bytes (loc, offset);
  printf ("Testing %s offset %d ungetc %d different %d %s%s %s\n",
	  test_open_case_name[c], full_offset, num_ungetc, num_ungetc_diff,
	  ungetc_fallback ? "fallback " : "", clear_ungetc_case_name[cl],
	  verify_case_name[v]);
  FILE *fp = open_test_stream (c);
  int cur_offset = read_to_test_loc (fp, loc, offset);
  clear_getpos_before (fp, cl);
  for (int i = 0; i < num_ungetc; i++)
    {
      unsigned char c = (i >= num_ungetc - num_ungetc_diff
			 ? cur_offset
			 : cur_offset - 1);
      if (ungetc_fallback)
	fail = true;
      TEST_COMPARE (ungetc (c, fp), c);
      fail = false;
      cur_offset--;
    }
  clear_getpos_after (fp, cl);
  int fd = -1;
  bool done_dup = false;
  if (verify_uses_fd (v))
    {
      fd = fileno (fp);
      TEST_VERIFY (fd != -1);
      if (clear_closes_file (cl))
	{
	  fd = xdup (fd);
	  done_dup = true;
	}
    }
  cur_offset += do_clear_ungetc (fp, cl, num_ungetc);
  switch (v)
    {
    case verify_read:
      for (;
	   cur_offset <= full_offset + 1 && cur_offset < 2 * BUFSIZ;
	   cur_offset++)
	TEST_COMPARE (getc (fp), (unsigned char) cur_offset);
      break;

    case verify_ftell:
      TEST_COMPARE (ftell (fp), cur_offset);
      break;

    case verify_ftello:
      TEST_COMPARE (ftello (fp), cur_offset);
      break;

    case verify_ftello64:
      TEST_COMPARE (ftello64 (fp), cur_offset);
      break;

    case verify_fd:
      TEST_COMPARE (lseek (fd, 0, SEEK_CUR), cur_offset);
      break;

    default:
      abort ();
    }
  if (! clear_closes_file (cl))
    {
      int ret = fclose (fp);
      TEST_COMPARE (ret, 0);
    }
  if (done_dup)
    xclose (fd);
}

int
do_test (void)
{
  setup ();
  for (enum test_open_case c = 0; c < test_open_max; c++)
    for (enum test_base_loc loc = 0; loc < base_loc_max; loc++)
      for (int offset = -2; offset <= 3; offset++)
	for (int num_ungetc = 0;
	     num_ungetc <= 2 && num_ungetc <= base_loc_to_bytes (loc, offset);
	     num_ungetc++)
	  for (int num_ungetc_diff = 0;
	       num_ungetc_diff <= num_ungetc;
	       num_ungetc_diff++)
	    for (int ungetc_fallback = 0;
		 ungetc_fallback <= (num_ungetc == 1 ? 1 : 0);
		 ungetc_fallback++)
	      for (enum clear_ungetc_case cl = 0; cl < clear_max; cl++)
		{
		  if (!clear_valid (c, cl))
		    continue;
		  if (base_loc_to_bytes (loc, offset) > 2 * BUFSIZ)
		    continue;
		  if ((base_loc_to_bytes (loc, offset)
		       - num_ungetc
		       + clear_offset (cl, num_ungetc)) < 0)
		    continue;
		  if ((base_loc_to_bytes (loc, offset)
		       - num_ungetc
		       + clear_offset (cl, num_ungetc)) > 2 * BUFSIZ)
		    continue;
		  for (enum verify_case v = 0; v < verify_max; v++)
		    {
		      if (!verify_valid (c, cl, v))
			continue;
		      test_one_case (c, loc, offset, num_ungetc,
				     num_ungetc_diff, ungetc_fallback, cl, v);
		    }
		}
  return 0;
}

#include <support/test-driver.c>