nss/nss_db/db-XXX.c

   1 /* Common code for DB-based databases in nss_db module.
   2    Copyright (C) 1996, 1997, 1998 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 not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 #include <db.h>
  21 #include <fcntl.h>
  22 #include <bits/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 ".db"
  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 enum nss_status
  60 internal_setent (int stayopen)
  61 {
  62   enum nss_status status = NSS_STATUS_SUCCESS;
  63   int err;
  64
  65   if (db == NULL)
  66     {
  67       err = __nss_db_open (DBFILE, DB_BTREE, DB_RDONLY, 0, NULL, NULL, &db);
  68
  69       if (err != 0)
  70         {
  71           __set_errno (err);
  72           status = err == EAGAIN ? NSS_STATUS_TRYAGAIN : NSS_STATUS_UNAVAIL;
  73         }
  74       else
  75         {
  76           /* We have to make sure the file is  `closed on exec'.  */
  77           int fd;
  78           int result, flags;
  79
  80           err = db->fd (db, &fd);
  81           if (err != 0)
  82             {
  83               __set_errno (err);
  84               result = -1;
  85             }
  86           else
  87             result = flags = fcntl (fd, F_GETFD, 0);
  88           if (result >= 0)
  89             {
  90               flags |= FD_CLOEXEC;
  91               result = fcntl (fd, F_SETFD, flags);
  92             }
  93           if (result < 0)
  94             {
  95               /* Something went wrong.  Close the stream and return a
  96                  failure.  */
  97               db->close (db, 0);
  98               db = NULL;
  99               status = NSS_STATUS_UNAVAIL;
 100             }
 101         }
 102     }
 103
 104   /* Remember STAYOPEN flag.  */
 105   if (db != NULL)
 106     keep_db |= stayopen;
 107
 108   return status;
 109 }
 110
 111
 112 /* Thread-safe, exported version of that.  */
 113 enum nss_status
 114 CONCAT(_nss_db_set,ENTNAME) (int stayopen)
 115 {
 116   enum nss_status status;
 117
 118   __libc_lock_lock (lock);
 119
 120   status = internal_setent (stayopen);
 121
 122   /* Reset the sequential index.  */
 123   entidx = 0;
 124
 125   __libc_lock_unlock (lock);
 126
 127   return status;
 128 }
 129
 130
 131 /* Close the database file.  */
 132 static void
 133 internal_endent (void)
 134 {
 135   if (db != NULL)
 136     {
 137       db->close (db, 0);
 138       db = NULL;
 139     }
 140 }
 141
 142
 143 /* Thread-safe, exported version of that.  */
 144 enum nss_status
 145 CONCAT(_nss_db_end,ENTNAME) (void)
 146 {
 147   __libc_lock_lock (lock);
 148
 149   internal_endent ();
 150
 151   /* Reset STAYOPEN flag.  */
 152   keep_db = 0;
 153
 154   __libc_lock_unlock (lock);
 155
 156   return NSS_STATUS_SUCCESS;
 157 }
 158 \f
 159 /* Do a database lookup for KEY.  */
 160 static enum nss_status
 161 lookup (DBT *key, struct STRUCTURE *result,
 162         void *buffer, size_t buflen, int *errnop H_ERRNO_PROTO)
 163 {
 164   char *p;
 165   enum nss_status status;
 166   int err;
 167   DBT value;
 168
 169   /* Open the database.  */
 170   status = internal_setent (keep_db);
 171   if (status != NSS_STATUS_SUCCESS)
 172     {
 173       *errnop = errno;
 174       H_ERRNO_SET (NETDB_INTERNAL);
 175       return status;
 176     }
 177
 178   /* Succeed iff it matches a value that parses correctly.  */
 179   value.flags = 0;
 180   err = db->get (db, NULL, key, &value, 0);
 181   if (err != 0)
 182     {
 183       if (err == DB_NOTFOUND)
 184         {
 185           H_ERRNO_SET (HOST_NOT_FOUND);
 186           status = NSS_STATUS_NOTFOUND;
 187         }
 188       else
 189         {
 190           *errnop = err;
 191           H_ERRNO_SET (NETDB_INTERNAL);
 192           status = NSS_STATUS_UNAVAIL;
 193         }
 194     }
 195   else if (buflen < value.size)
 196     {
 197       /* No room to copy the data to.  */
 198       *errnop = ERANGE;
 199       H_ERRNO_SET (NETDB_INTERNAL);
 200       status = NSS_STATUS_TRYAGAIN;
 201     }
 202   else
 203     {
 204       /* Copy the result to a safe place.  */
 205       p = (char *) memcpy (buffer, value.data, value.size);
 206
 207       /* Skip leading blanks.  */
 208       while (isspace (*p))
 209         ++p;
 210
 211       err = parse_line (p, result, buffer, buflen, errnop);
 212
 213       if (err == 0)
 214         {
 215           /* If the key begins with '0' we are trying to get the next
 216              entry.  We want to ignore unparsable lines in this case.  */
 217           if (((char *) key->data)[0] == '0')
 218             {
 219               /* Super magical return value.  We need to tell our caller
 220                  that it should continue looping.  This value cannot
 221                  happen in other cases.  */
 222               status = NSS_STATUS_RETURN;
 223             }
 224           else
 225             {
 226               H_ERRNO_SET (HOST_NOT_FOUND);
 227               status = NSS_STATUS_NOTFOUND;
 228             }
 229         }
 230       else if (err < 0)
 231         {
 232           H_ERRNO_SET (NETDB_INTERNAL);
 233           status = NSS_STATUS_TRYAGAIN;
 234         }
 235       else
 236         status = NSS_STATUS_SUCCESS;
 237     }
 238
 239   if (! keep_db)
 240     internal_endent ();
 241
 242   return status;
 243 }
 244
 245
 246 /* Macro for defining lookup functions for this DB-based database.
 247
 248    NAME is the name of the lookup; e.g. `pwnam'.
 249
 250    KEYPATTERN gives `printf' args to construct a key string;
 251    e.g. `(".%s", name)'.
 252
 253    KEYSIZE gives the allocation size of a buffer to construct it in;
 254    e.g. `1 + strlen (name)'.
 255
 256    PROTO describes the arguments for the lookup key;
 257    e.g. `const char *name'.
 258
 259    BREAK_IF_MATCH is ignored, but used by ../nss_files/files-XXX.c.  */
 260
 261 #define DB_LOOKUP(name, keysize, keypattern, break_if_match, proto...)        \
 262 enum nss_status                                                               \
 263 _nss_db_get##name##_r (proto,                                                 \
 264                        struct STRUCTURE *result,                              \
 265                        char *buffer, size_t buflen, int *errnop H_ERRNO_PROTO)\
 266 {                                                                             \
 267   DBT key;                                                                    \
 268   enum nss_status status;                                                     \
 269   const size_t size = (keysize) + 1;                                          \
 270   key.data = __alloca (size);                                                 \
 271   key.size = KEYPRINTF keypattern;                                            \
 272   key.flags = 0;                                                              \
 273   __libc_lock_lock (lock);                                                    \
 274   status = lookup (&key, result, buffer, buflen, errnop H_ERRNO_ARG);         \
 275   __libc_lock_unlock (lock);                                                  \
 276   return status;                                                              \
 277 }
 278
 279 #define KEYPRINTF(pattern, args...) snprintf (key.data, size, pattern ,##args)
 280 \f
 281
 282
 283
 284 /* Return the next entry from the database file, doing locking.  */
 285 enum nss_status
 286 CONCAT(_nss_db_get,ENTNAME_r) (struct STRUCTURE *result, char *buffer,
 287                                size_t buflen, int *errnop H_ERRNO_PROTO)
 288 {
 289   /* Return next entry in host file.  */
 290   enum nss_status status;
 291   char buf[20];
 292   DBT key;
 293
 294   __libc_lock_lock (lock);
 295
 296   /* Loop until we find a valid entry or hit EOF.  See above for the
 297      special meaning of the status value.  */
 298   do
 299     {
 300       key.size = snprintf (key.data = buf, sizeof buf, "0%u", entidx++);
 301       key.flags = 0;
 302       status = lookup (&key, result, buffer, buflen, errnop H_ERRNO_ARG);
 303       if (status == NSS_STATUS_TRYAGAIN
 304 #ifdef NEED_H_ERRNO
 305           && *herrnop == NETDB_INTERNAL
 306 #endif
 307           && *errnop == ERANGE)
 308         /* Give the user a chance to get the same entry with a larger
 309            buffer.  */
 310         --entidx;
 311     }
 312   while (status == NSS_STATUS_RETURN);
 313
 314   __libc_lock_unlock (lock);
 315
 316   return status;
 317 }