nss/nss_db/db-XXX.c

   1 /* Common code for DB-based databases in nss_db module.
   2 Copyright (C) 1996 Free Software Foundation, Inc.
   3 This file is part of the GNU C Library.
   4
   5 The GNU C Library is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU Library General Public License as
   7 published by the Free Software Foundation; either version 2 of the
   8 License, or (at your option) any later version.
   9
  10 The GNU C Library is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 Library General Public License for more details.
  14
  15 You should have received a copy of the GNU Library General Public
  16 License along with the GNU C Library; see the file COPYING.LIB.  If
  17 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  18 Cambridge, MA 02139, USA.  */
  19
  20 #include <db.h>
  21 #include <fcntl.h>
  22 #include <libc-lock.h>
  23 #include "nsswitch.h"
  24
  25 /* These symbols are defined by the including source file:
  26
  27    ENTNAME -- database name of the structure and functions (hostent, pwent).
  28    STRUCTURE -- struct name, define only if not ENTNAME (passwd, group).
  29    DATABASE -- database file name, ("hosts", "passwd")
  30
  31    NEED_H_ERRNO - defined iff an arg `int *herrnop' is used.
  32 */
  33
  34 #define ENTNAME_r       CONCAT(ENTNAME,_r)
  35
  36 #include <paths.h>
  37 #define DBFILE          _PATH_VARDB DATABASE
  38
  39 #ifdef NEED_H_ERRNO
  40 #define H_ERRNO_PROTO   , int *herrnop
  41 #define H_ERRNO_ARG     , herrnop
  42 #define H_ERRNO_SET(val) (*herrnop = (val))
  43 #else
  44 #define H_ERRNO_PROTO
  45 #define H_ERRNO_ARG
  46 #define H_ERRNO_SET(val) ((void) 0)
  47 #endif
  48
  49 /* Locks the static variables in this file.  */
  50 __libc_lock_define_initialized (static, lock)
  51 \f
  52 /* Maintenance of the shared handle open on the database.  */
  53
  54 static DB *db;
  55 static int keep_db;
  56 static unsigned int entidx;     /* Index for `getENTNAME'. */
  57
  58 /* Open database file if not already opened.  */
  59 static int
  60 internal_setent (int stayopen)
  61 {
  62   int status = NSS_STATUS_SUCCESS;
  63
  64   if (db == NULL)
  65     {
  66       db = dbopen (DBFILE, O_RDONLY, 0, DB_BTREE, NULL);
  67
  68       if (db == NULL)
  69         status = NSS_STATUS_UNAVAIL;
  70     }
  71
  72   /* Remember STAYOPEN flag.  */
  73   if (db != NULL)
  74     keep_db |= stayopen;
  75
  76   return status;
  77 }
  78
  79
  80 /* Thread-safe, exported version of that.  */
  81 int
  82 CONCAT(_nss_files_set,ENTNAME) (int stayopen)
  83 {
  84   int status;
  85
  86   __libc_lock_lock (lock);
  87
  88   status = internal_setent (stayopen);
  89
  90   /* Reset the sequential index.  */
  91   entidx = 0;
  92
  93   __libc_lock_unlock (lock);
  94
  95   return status;
  96 }
  97
  98
  99 /* Close the database file.  */
 100 static void
 101 internal_endent (void)
 102 {
 103   if (db != NULL)
 104     {
 105       (*db->close) (db);
 106       db = NULL;
 107     }
 108 }
 109
 110
 111 /* Thread-safe, exported version of that.  */
 112 int
 113 CONCAT(_nss_files_end,ENTNAME) (void)
 114 {
 115   __libc_lock_lock (lock);
 116
 117   internal_endent ();
 118
 119   /* Reset STAYOPEN flag.  */
 120   keep_db = 0;
 121
 122   __libc_lock_unlock (lock);
 123
 124   return NSS_STATUS_SUCCESS;
 125 }
 126 \f
 127 /* Do a database lookup for KEY.  */
 128 static enum nss_status
 129 lookup (const DBT *key, struct STRUCTURE *result,
 130         void *buffer, int buflen H_ERRNO_PROTO)
 131 {
 132   enum nss_status status;
 133   DBT value;
 134
 135   /* Open the database.  */
 136   internal_setent (keep_db);
 137
 138   /* Succeed iff it matches a value that parses correctly.  */
 139   status = (((*db->get) (db, key, &value, 0) == 0 &&
 140              parse_line (value.data, result, buffer, buflen) == 0)
 141             ? NSS_STATUS_SUCCESS : NSS_STATUS_NOTFOUND);
 142
 143   if (! keep_db)
 144     internal_endent ();
 145
 146   return status;
 147 }
 148
 149
 150 /* Macro for defining lookup functions for this DB-based database.
 151
 152    NAME is the name of the lookup; e.g. `pwnam'.
 153
 154    KEYPATTERN gives `printf' args to construct a key string;
 155    e.g. `(".%s", name)'.
 156
 157    KEYSIZE gives the allocation size of a buffer to construct it in;
 158    e.g. `1 + strlen (name)'.
 159
 160    PROTO describes the arguments for the lookup key;
 161    e.g. `const char *name'.
 162
 163    BREAK_IF_MATCH is ignored, but used by ../nss_files/files-XXX.c.  */
 164
 165 #define DB_LOOKUP(name, keysize, keypattern, break_if_match, proto...)        \
 166 enum nss_status                                                               \
 167 _nss_files_get##name##_r (proto,                                              \
 168                           struct STRUCTURE *result,                           \
 169                           char *buffer, int buflen H_ERRNO_PROTO)             \
 170 {                                                                             \
 171   DBT key;                                                                    \
 172   enum nss_status status;                                                     \
 173   const size_t size = (keysize);                                              \
 174   key.data = __alloca (size);                                                 \
 175   key.size = KEYPRINTF keypattern;                                            \
 176   __libc_lock_lock (lock);                                                    \
 177   status = lookup (&key, result, buffer, buflen H_ERRNO_ARG);                 \
 178   __libc_lock_unlock (lock);                                                  \
 179   return status;                                                              \
 180 }
 181
 182 #define KEYPRINTF(pattern, args...) snprintf (key.data, size, pattern ,##args)
 183 \f
 184
 185
 186
 187 /* Return the next entry from the database file, doing locking.  */
 188 enum nss_status
 189 CONCAT(_nss_files_get,ENTNAME_r) (struct STRUCTURE *result,
 190                                   char *buffer, int buflen H_ERRNO_PROTO)
 191 {
 192   /* Return next entry in host file.  */
 193   enum nss_status status;
 194   char buf[20];
 195   DBT key;
 196
 197   __libc_lock_lock (lock);
 198   key.size = 1 + snprintf (key.data = buf, sizeof buf, "0%u", entidx++);
 199   status = lookup (&key, result, buffer, buflen H_ERRNO_ARG);
 200   __libc_lock_unlock (lock);
 201
 202   return status;
 203 }