/* Common code for DB-based databases in nss_db module.

   Copyright (C) 1996-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 <dlfcn.h>

#include <fcntl.h>

#include <stdint.h>

#include <sys/mman.h>

#include <libc-lock.h>

#include "nsswitch.h"

#include "nss_db.h"

/* The hashing function we use.  */

#include "../intl/hash-string.h"

/* These symbols are defined by the including source file:

   ENTNAME -- database name of the structure and functions (hostent, pwent).

   STRUCTURE -- struct name, define only if not ENTNAME (passwd, group).

   DATABASE -- database file name, ("hosts", "passwd")

   NEED_H_ERRNO - defined iff an arg `int *herrnop' is used.

*/

#define ENTNAME_r	CONCAT(ENTNAME,_r)

#include <paths.h>

#define	DBFILE		_PATH_VARDB DATABASE ".db"

#ifdef NEED_H_ERRNO

# define H_ERRNO_PROTO	, int *herrnop

# define H_ERRNO_ARG	, herrnop

# define H_ERRNO_SET(val) (*herrnop = (val))

#else

# define H_ERRNO_PROTO

# define H_ERRNO_ARG

# define H_ERRNO_SET(val) ((void) 0)

#endif

/* State for this database.  */

static struct nss_db_map state;

/* Lock to protect the state and global variables.  */

__libc_lock_define (static , lock);

/* Maintenance of the shared handle open on the database.  */

static int keep_db;

static const char *entidx;

/* Open the database.  */

enum nss_status

CONCAT(_nss_db_set,ENTNAME) (int stayopen)

{

  enum nss_status status;

  __libc_lock_lock (lock);

  status = internal_setent (DBFILE, &state);

  if (status == NSS_STATUS_SUCCESS)

    {

      /* Remember STAYOPEN flag.  */

      keep_db |= stayopen;

      /* Reset the sequential index.  */

      entidx  = NULL;

    }

  __libc_lock_unlock (lock);

  return status;

}

/* Close it again.  */

enum nss_status

CONCAT(_nss_db_end,ENTNAME) (void)

{

  __libc_lock_lock (lock);

  internal_endent (&state);

  /* Reset STAYOPEN flag.  */

  keep_db = 0;

  __libc_lock_unlock (lock);

  return NSS_STATUS_SUCCESS;

}

/* Macro for defining lookup functions for this DB-based database.

   NAME is the name of the lookup; e.g. `pwnam'.

   DB_CHAR is index indicator for the database.

   KEYPATTERN gives `printf' args to construct a key string;

   e.g. `("%d", id)'.

   KEYSIZE gives the allocation size of a buffer to construct it in;

   e.g. `1 + sizeof (id) * 4'.

   PROTO is the potentially empty list of other parameters.

   BREAK_IF_MATCH is a block of code which compares `struct STRUCTURE *result'

   to the lookup key arguments and does `break;' if they match.  */

#define DB_LOOKUP(name, db_char, keysize, keypattern, break_if_match, proto...)\

enum nss_status								      \

 _nss_db_get##name##_r (proto, struct STRUCTURE *result,		      \

			char *buffer, size_t buflen, int *errnop H_ERRNO_PROTO)\

{									      \

  struct parser_data *data = (void *) buffer;				      \

									      \

  if (buflen < sizeof *data)						      \

    {									      \

      *errnop = ERANGE;							      \

      H_ERRNO_SET (NETDB_INTERNAL);					      \

      return NSS_STATUS_TRYAGAIN;					      \

    }									      \

									      \

  struct nss_db_map state = { NULL, 0 };				      \

  enum nss_status status = internal_setent (DBFILE, &state);		      \

  if (status != NSS_STATUS_SUCCESS)					      \

    {									      \

      *errnop = errno;							      \

      H_ERRNO_SET (NETDB_INTERNAL);					      \

      return status;							      \

    }									      \

									      \

  const struct nss_db_header *header = state.header;			      \

  int i;								      \

  for (i = 0; i < header->ndbs; ++i)					      \

    if (header->dbs[i].id == db_char)					      \

      break;								      \

  if (i == header->ndbs)						      \

    {									      \

      status = NSS_STATUS_UNAVAIL;					      \

      goto out;								      \

    }									      \

									      \

  char *key;								      \

  if (db_char == '.')							      \

    key = (char *) IGNOREPATTERN keypattern;				      \

  else									      \

    {									      \

      const size_t size = (keysize) + 1;				      \

      key = alloca (size);						      \

									      \

      KEYPRINTF keypattern;						      \

    }									      \

									      \

  const stridx_t *hashtable						      \

    = (const stridx_t *) ((const char *) header				      \

			  + header->dbs[i].hashoffset);			      \

  const char *valstrtab = (const char *) header + header->valstroffset;	      \

  uint32_t hashval = __hash_string (key);				      \

  size_t hidx = hashval % header->dbs[i].hashsize;			      \

  size_t hval2 = 1 + hashval % (header->dbs[i].hashsize - 2);		      \

									      \

  status = NSS_STATUS_NOTFOUND;						      \

  while (hashtable[hidx] != ~((stridx_t) 0))				      \

    {									      \

      const char *valstr = valstrtab + hashtable[hidx];			      \

      size_t len = strlen (valstr) + 1;					      \

      if (len > buflen)							      \

	{								      \

	  /* No room to copy the data to.  */				      \

	  *errnop = ERANGE;						      \

	  H_ERRNO_SET (NETDB_INTERNAL);					      \

	  status = NSS_STATUS_TRYAGAIN;					      \

	  break;							      \

	}								      \

									      \

      /* Copy the string to a place where it can be modified.  */	      \

      char *p = memcpy (buffer, valstr, len);				      \

									      \

      int err = parse_line (p, result, data, buflen, errnop EXTRA_ARGS);      \

									      \

      /* Advance before break_if_match, lest it uses continue to skip

	 to the next entry.  */						      \

      if ((hidx += hval2) >= header->dbs[i].hashsize)			      \

	hidx -= header->dbs[i].hashsize;				      \

									      \

      if (err > 0)							      \

	{								      \

	  status = NSS_STATUS_SUCCESS;					      \

	  break_if_match;						      \

	  status = NSS_STATUS_NOTFOUND;					      \

	}								      \

      else if (err == -1)						      \

	{								      \

	  H_ERRNO_SET (NETDB_INTERNAL);					      \

	  status = NSS_STATUS_TRYAGAIN;					      \

	  break;							      \

	}								      \

    }									      \

									      \

  if (status == NSS_STATUS_NOTFOUND)					      \

    H_ERRNO_SET (HOST_NOT_FOUND);					      \

									      \

 out:									      \

  internal_endent (&state);						      \

									      \

  return status;							      \

}

#define KEYPRINTF(pattern, args...) snprintf (key, size, pattern ,##args)

#define IGNOREPATTERN(pattern, arg1, args...) (char *) (uintptr_t) arg1

/* Return the next entry from the database file, doing locking.  */

enum nss_status

CONCAT(_nss_db_get,ENTNAME_r) (struct STRUCTURE *result, char *buffer,

			       size_t buflen, int *errnop H_ERRNO_PROTO)

{

  /* Return next entry in host file.  */

  enum nss_status status;

  struct parser_data *data = (void *) buffer;

  if (buflen < sizeof *data)

    {

      *errnop = ERANGE;

      H_ERRNO_SET (NETDB_INTERNAL);

      return NSS_STATUS_TRYAGAIN;

    }

  __libc_lock_lock (lock);

  if (state.header == NULL)

    {

      status = internal_setent (DBFILE, &state);

      if (status != NSS_STATUS_SUCCESS)

	{

	  *errnop = errno;

	  H_ERRNO_SET (NETDB_INTERNAL);

	  goto out;

	}

      entidx = NULL;

    }

  /* Start from the beginning if freshly initialized or reset

     requested by set*ent.  */

  if (entidx == NULL)

    entidx = (const char *) state.header + state.header->valstroffset;

  status = NSS_STATUS_UNAVAIL;

  if (state.header != MAP_FAILED)

    {

      const char *const end = ((const char *) state.header

			       + state.header->valstroffset

			       + state.header->valstrlen);

      while (entidx < end)

	{

	  const char *next = rawmemchr (entidx, '\0') + 1;

	  size_t len = next - entidx;

	  if (len > buflen)

	    {

	      /* No room to copy the data to.  */

	      *errnop = ERANGE;

	      H_ERRNO_SET (NETDB_INTERNAL);

	      status = NSS_STATUS_TRYAGAIN;

	      break;

	    }

	  /* Copy the string to a place where it can be modified.  */

	  char *p = memcpy (buffer, entidx, len);

	  int err = parse_line (p, result, data, buflen, errnop EXTRA_ARGS);

	  if (err > 0)

	    {

	      status = NSS_STATUS_SUCCESS;

	      entidx = next;

	      break;

	    }

	  if (err < 0)

	    {

	      H_ERRNO_SET (NETDB_INTERNAL);

	      status = NSS_STATUS_TRYAGAIN;

	      break;

	    }

	  /* Continue with the next record, this one is ill-formed.  */

	  entidx = next;

	}

    }

 out:

  __libc_lock_unlock (lock);

  return status;

}