/* Template generic NSS service provider.  See nss_test.h for usage.
   Copyright (C) 2017-2022 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 <errno.h>
#include <nss.h>
#include <pthread.h>
#include <string.h>
#include <stdio.h>
#include <alloc_buffer.h>


/* We need to be able to handle NULLs "properly" within the testsuite,
   to test known bad data.  */
#define alloc_buffer_maybe_copy_string(b,s) s ? alloc_buffer_copy_string (b, s) : NULL;

/* This file is the master template.  Other instances of this test
   module should define NAME(x) to have their name instead of "test1",
   then include this file.
*/
#define NAME_(x,n) _nss_##n##_##x
#ifndef NAME
#define NAME(x) NAME_(x,test1)
#endif
#define NAMESTR__(x) #x
#define NAMESTR_(x) NAMESTR__(x)
#define NAMESTR(x) NAMESTR_(NAME(x))

#include "nss_test.h"

/* -------------------------------------------------- */
/* Default Data.  */

static struct passwd default_pwd_data[] =
  {
#define PWD(u) \
    { .pw_name = (char *) "name" #u, .pw_passwd = (char *) "*", .pw_uid = u,  \
      .pw_gid = 100, .pw_gecos = (char *) "*", .pw_dir = (char *) "*",	      \
      .pw_shell = (char *) "*" }
    PWD (30),
    PWD (100),
    PWD (200),
    PWD (60),
    PWD (20000)
  };
#define default_npwd_data \
  (sizeof (default_pwd_data) / sizeof (default_pwd_data[0]))

static struct passwd *pwd_data = default_pwd_data;
static int npwd_data = default_npwd_data;

static struct group *grp_data = NULL;
static int ngrp_data = 0;

static struct spwd *spwd_data = NULL;
static int nspwd_data = 0;

static struct hostent *host_data = NULL;
static int nhost_data = 0;

/* This function will get called, and once per session, look back into
   the test case's executable for an init hook function, and call
   it.  */

static int initted = 0;
static void
init(void)
{
  test_tables t;
  int i;

  if (initted)
    return;
  if (NAME(init_hook))
    {
      memset (&t, 0, sizeof (t));
      NAME(init_hook)(&t);

      if (t.pwd_table)
	{
	  pwd_data = t.pwd_table;
	  for (i=0; ! PWD_ISLAST(& pwd_data[i]); i++)
	    ;
	  npwd_data = i;
	}

      if (t.grp_table)
	{
	  grp_data = t.grp_table;
	  for (i=0; ! GRP_ISLAST(& grp_data[i]); i++)
	    ;
	  ngrp_data = i;
	}
      if (t.spwd_table)
	{
	  spwd_data = t.spwd_table;
	  for (i=0; ! SPWD_ISLAST(& spwd_data[i]); i++)
	    ;
	  nspwd_data = i;
	}
      if (t.host_table)
	{
	  host_data = t.host_table;
	  for (i=0; ! HOST_ISLAST(& host_data[i]); i++)
	    ;
	  nhost_data = i;
	}
    }
  initted = 1;
}

/* -------------------------------------------------- */
/* Password handling.  */

static size_t pwd_iter;
#define CURPWD pwd_data[pwd_iter]

static pthread_mutex_t pwd_lock = PTHREAD_MUTEX_INITIALIZER;

enum nss_status
NAME(setpwent) (int stayopen)
{
  init();
  pwd_iter = 0;
  return NSS_STATUS_SUCCESS;
}


enum nss_status
NAME(endpwent) (void)
{
  init();
  return NSS_STATUS_SUCCESS;
}

static enum nss_status
copy_passwd (struct passwd *result, struct passwd *local,
	    char *buffer, size_t buflen, int *errnop)
{
  struct alloc_buffer buf = alloc_buffer_create (buffer, buflen);

  result->pw_name = alloc_buffer_maybe_copy_string (&buf, local->pw_name);
  result->pw_passwd = alloc_buffer_maybe_copy_string (&buf, local->pw_passwd);
  result->pw_uid = local->pw_uid;
  result->pw_gid = local->pw_gid;
  result->pw_gecos = alloc_buffer_maybe_copy_string (&buf, local->pw_gecos);
  result->pw_dir = alloc_buffer_maybe_copy_string (&buf, local->pw_dir);
  result->pw_shell = alloc_buffer_maybe_copy_string (&buf, local->pw_shell);

  if (alloc_buffer_has_failed (&buf))
    {
      *errnop = ERANGE;
      return NSS_STATUS_TRYAGAIN;
    }

  return NSS_STATUS_SUCCESS;
}

enum nss_status
NAME(getpwent_r) (struct passwd *result, char *buffer, size_t buflen,
		       int *errnop)
{
  int res = NSS_STATUS_SUCCESS;

  init();
  pthread_mutex_lock (&pwd_lock);

  if (pwd_iter >= npwd_data)
    res = NSS_STATUS_NOTFOUND;
  else
    {
      res = copy_passwd (result, &CURPWD, buffer, buflen, errnop);
      ++pwd_iter;
    }

  pthread_mutex_unlock (&pwd_lock);

  return res;
}


enum nss_status
NAME(getpwuid_r) (uid_t uid, struct passwd *result, char *buffer,
		       size_t buflen, int *errnop)
{
  init();
  for (size_t idx = 0; idx < npwd_data; ++idx)
    if (pwd_data[idx].pw_uid == uid)
      return copy_passwd (result, &pwd_data[idx], buffer, buflen, errnop);

  return NSS_STATUS_NOTFOUND;
}


enum nss_status
NAME(getpwnam_r) (const char *name, struct passwd *result, char *buffer,
		       size_t buflen, int *errnop)
{
  init();
  for (size_t idx = 0; idx < npwd_data; ++idx)
    if (strcmp (pwd_data[idx].pw_name, name) == 0)
      return copy_passwd (result, &pwd_data[idx], buffer, buflen, errnop);

  return NSS_STATUS_NOTFOUND;
}

/* -------------------------------------------------- */
/* Group handling.  */

static size_t grp_iter;
#define CURGRP grp_data[grp_iter]

static pthread_mutex_t grp_lock = PTHREAD_MUTEX_INITIALIZER;

enum nss_status
NAME(setgrent) (int stayopen)
{
  init();
  grp_iter = 0;
  return NSS_STATUS_SUCCESS;
}


enum nss_status
NAME(endgrent) (void)
{
  init();
  return NSS_STATUS_SUCCESS;
}

static enum nss_status
copy_group (struct group *result, struct group *local,
	    char *buffer, size_t buflen, int *errnop)
{
  struct alloc_buffer buf = alloc_buffer_create (buffer, buflen);
  char **memlist;
  int i;

  if (local->gr_mem)
    {
      i = 0;
      while (local->gr_mem[i])
	++i;

      memlist = alloc_buffer_alloc_array (&buf, char *, i + 1);

      if (memlist) {
	for (i = 0; local->gr_mem[i]; ++i)
	  memlist[i] = alloc_buffer_maybe_copy_string (&buf, local->gr_mem[i]);
	memlist[i] = NULL;
      }

      result->gr_mem = memlist;
    }
  else
    result->gr_mem = NULL;

  result->gr_name = alloc_buffer_maybe_copy_string (&buf, local->gr_name);
  result->gr_passwd = alloc_buffer_maybe_copy_string (&buf, local->gr_passwd);
  result->gr_gid = local->gr_gid;

  if (alloc_buffer_has_failed (&buf))
    {
      *errnop = ERANGE;
      return NSS_STATUS_TRYAGAIN;
    }

  return NSS_STATUS_SUCCESS;
}


enum nss_status
NAME(getgrent_r) (struct group *result, char *buffer, size_t buflen,
		       int *errnop)
{
  int res = NSS_STATUS_SUCCESS;

  init();
  pthread_mutex_lock (&grp_lock);

  if (grp_iter >= ngrp_data)
    res = NSS_STATUS_NOTFOUND;
  else
    {
      res = copy_group (result, &CURGRP, buffer, buflen, errnop);
      ++grp_iter;
    }

  pthread_mutex_unlock (&grp_lock);

  return res;
}


enum nss_status
NAME(getgrgid_r) (gid_t gid, struct group *result, char *buffer,
		  size_t buflen, int *errnop)
{
  init();
  for (size_t idx = 0; idx < ngrp_data; ++idx)
    if (grp_data[idx].gr_gid == gid)
      return copy_group (result, &grp_data[idx], buffer, buflen, errnop);

  return NSS_STATUS_NOTFOUND;
}


enum nss_status
NAME(getgrnam_r) (const char *name, struct group *result, char *buffer,
		       size_t buflen, int *errnop)
{
  init();
  for (size_t idx = 0; idx < ngrp_data; ++idx)
    if (strcmp (pwd_data[idx].pw_name, name) == 0)
      {
	return copy_group (result, &grp_data[idx], buffer, buflen, errnop);
      }

  return NSS_STATUS_NOTFOUND;
}

/* -------------------------------------------------- */
/* Shadow password handling.  */

static size_t spwd_iter;
#define CURSPWD spwd_data[spwd_iter]

static pthread_mutex_t spwd_lock = PTHREAD_MUTEX_INITIALIZER;

enum nss_status
NAME(setspent) (int stayopen)
{
  init();
  spwd_iter = 0;
  return NSS_STATUS_SUCCESS;
}


enum nss_status
NAME(endspwent) (void)
{
  init();
  return NSS_STATUS_SUCCESS;
}

static enum nss_status
copy_shadow (struct spwd *result, struct spwd *local,
	    char *buffer, size_t buflen, int *errnop)
{
  struct alloc_buffer buf = alloc_buffer_create (buffer, buflen);

  result->sp_namp = alloc_buffer_maybe_copy_string (&buf, local->sp_namp);
  result->sp_pwdp = alloc_buffer_maybe_copy_string (&buf, local->sp_pwdp);
  result->sp_lstchg = local->sp_lstchg;
  result->sp_min = local->sp_min;
  result->sp_max = local->sp_max;
  result->sp_warn = local->sp_warn;
  result->sp_inact = local->sp_inact;
  result->sp_expire = local->sp_expire;
  result->sp_flag = local->sp_flag;

  if (alloc_buffer_has_failed (&buf))
    {
      *errnop = ERANGE;
      return NSS_STATUS_TRYAGAIN;
    }

  return NSS_STATUS_SUCCESS;
}

enum nss_status
NAME(getspent_r) (struct spwd *result, char *buffer, size_t buflen,
		  int *errnop)
{
  int res = NSS_STATUS_SUCCESS;

  init();
  pthread_mutex_lock (&spwd_lock);

  if (spwd_iter >= nspwd_data)
    res = NSS_STATUS_NOTFOUND;
  else
    {
      res = copy_shadow (result, &CURSPWD, buffer, buflen, errnop);
      ++spwd_iter;
    }

  pthread_mutex_unlock (&spwd_lock);

  return res;
}

enum nss_status
NAME(getspnam_r) (const char *name, struct spwd *result, char *buffer,
		  size_t buflen, int *errnop)
{
  init();
  for (size_t idx = 0; idx < nspwd_data; ++idx)
    if (strcmp (spwd_data[idx].sp_namp, name) == 0)
      return copy_shadow (result, &spwd_data[idx], buffer, buflen, errnop);

  return NSS_STATUS_NOTFOUND;
}

/* -------------------------------------------------- */
/* Host handling.  */

static size_t host_iter;
#define CURHOST host_data[host_iter]

static pthread_mutex_t host_lock = PTHREAD_MUTEX_INITIALIZER;

enum nss_status
NAME(sethostent) (int stayopen)
{
  init();
  host_iter = 0;
  return NSS_STATUS_SUCCESS;
}


enum nss_status
NAME(endhostent) (void)
{
  init();
  return NSS_STATUS_SUCCESS;
}

static enum nss_status
copy_host (struct hostent *result, struct hostent *local,
	    char *buffer, size_t buflen, int *errnop)
{
  struct alloc_buffer buf = alloc_buffer_create (buffer, buflen);
  char **memlist;
  int i, j;

  if (local->h_addr_list)
    {
      i = 0;
      while (local->h_addr_list[i])
	++i;

      memlist = alloc_buffer_alloc_array (&buf, char *, i + 1);

      if (memlist) {
	for (j = 0; j < i; ++j)
	  memlist[j] = alloc_buffer_maybe_copy_string (&buf, local->h_addr_list[j]);
	memlist[j] = NULL;
      }

      result->h_addr_list = memlist;
    }
  else
    {
      result->h_addr_list = NULL;
    }

  result->h_aliases = NULL;
  result->h_addrtype = AF_INET;
  result->h_length = 4;
  result->h_name = alloc_buffer_maybe_copy_string (&buf, local->h_name);

  if (alloc_buffer_has_failed (&buf))
    {
      *errnop = ERANGE;
      return NSS_STATUS_TRYAGAIN;
    }

  return NSS_STATUS_SUCCESS;
}


enum nss_status
NAME(gethostent_r) (struct hostent *ret, char *buffer, size_t buflen,
		    struct hostent **result, int *errnop)
{
  int res = NSS_STATUS_SUCCESS;

  init();
  pthread_mutex_lock (&host_lock);

  if (host_iter >= nhost_data)
    {
      res = NSS_STATUS_NOTFOUND;
      *result = NULL;
    }
  else
    {
      res = copy_host (ret, &CURHOST, buffer, buflen, errnop);
      *result = ret;
      ++host_iter;
    }

  pthread_mutex_unlock (&host_lock);

  return res;
}

enum nss_status
NAME(gethostbyname3_r) (const char *name, int af, struct hostent *ret,
			     char *buffer, size_t buflen, int *errnop,
			     int *h_errnop, int32_t *ttlp, char **canonp)
{
  init();

  for (size_t idx = 0; idx < nhost_data; ++idx)
    if (strcmp (host_data[idx].h_name, name) == 0)
      return copy_host (ret, & host_data[idx], buffer, buflen, h_errnop);

  return NSS_STATUS_NOTFOUND;
}

enum nss_status
NAME(gethostbyname_r) (const char *name, struct hostent *result,
		       char *buffer, size_t buflen,
		       int *errnop, int *h_errnop)
{
  return NAME(gethostbyname3_r) (name, AF_INET, result, buffer, buflen,
				 errnop, h_errnop, NULL, NULL);
}

enum nss_status
NAME(gethostbyname2_r) (const char *name, int af, struct hostent *result,
			char *buffer, size_t buflen,
			int *errnop, int *h_errnop)
{
  return NAME(gethostbyname3_r) (name, af, result, buffer, buflen,
				 errnop, h_errnop, NULL, NULL);
}

enum nss_status
NAME(gethostbyaddr2_r) (const void *addr, socklen_t len, int af,
			struct hostent *result, char *buffer, size_t buflen,
			int *errnop, int *h_errnop, int32_t *ttlp)
{
  init();

  /* Support this later.  */
  if (len != 4)
    return NSS_STATUS_NOTFOUND;

  for (size_t idx = 0; idx < nhost_data; ++idx)
    if (memcmp (host_data[idx].h_addr, addr, len) == 0)
      return copy_host (result, & host_data[idx], buffer, buflen, h_errnop);

  return NSS_STATUS_NOTFOUND;
}

/* Note: only the first address is supported, intentionally.  */
enum nss_status
NAME(gethostbyaddr_r) (const void *addr, socklen_t len, int af,
		       struct hostent *result, char *buffer, size_t buflen,
		       int *errnop, int *h_errnop)
{
  return NAME(gethostbyaddr2_r) (addr, len, af, result, buffer, buflen,
				 errnop, h_errnop, NULL);
}