/* Template generic NSS service provider.  See nss_test.h for usage.

   Copyright (C) 2017-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; if not, see

   <http://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;

/* 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;

	}

    }

  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 (&pwd_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;

}